meno-astro 0.1.12 → 0.1.14

package/dist/chunks/chunk-5BVKIPKS.js

@@ -0,0 +1,9 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+export {
+  __esm
+};
+//# sourceMappingURL=chunk-5BVKIPKS.js.map

package/dist/chunks/{chunk-D5DHUDKR.js → chunk-ENCYNJWV.js}

@@ -3,36 +3,16 @@ import {
   extractLocaleFromPath,
   isI18nValue,
   resolveI18nValue
-} from "./chunk-V4SUAPTT.js";
-import {
-  __require
-} from "./chunk-ZYQNHI3W.js";
+} from "./chunk-GITHFAZG.js";
 
 // lib/runtime/i18n.ts
-var store;
-var fallbackContext;
-try {
-  const { AsyncLocalStorage } = __require("node:async_hooks");
-  store = new AsyncLocalStorage();
-} catch {
-  store = void 0;
-}
+import { AsyncLocalStorage } from "node:async_hooks";
+var store = new AsyncLocalStorage();
 function runWithLocale(locale, config, fn) {
-  const ctx = { locale, config };
-  if (store) {
-    return store.run(ctx, fn);
-  }
-  const prev = fallbackContext;
-  fallbackContext = ctx;
-  try {
-    return fn();
-  } finally {
-    fallbackContext = prev;
-  }
+  return store.run({ locale, config }, fn);
 }
 function getLocaleContext() {
-  if (store) return store.getStore();
-  return fallbackContext;
+  return store.getStore();
 }
 function localeFromAstro(astro, config) {
   if (astro?.currentLocale) return astro.currentLocale;
@@ -88,4 +68,4 @@ export {
   deriveLocale,
   createLocaleMiddleware
 };
-//# sourceMappingURL=chunk-D5DHUDKR.js.map
+//# sourceMappingURL=chunk-ENCYNJWV.js.map

package/dist/chunks/chunk-ENCYNJWV.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../lib/runtime/i18n.ts", "../../lib/runtime/middleware.ts"],
+  "sourcesContent": ["/**\n * meno-astro \u2014 i18n runtime resolver.\n *\n * Emitted `.astro` markup carries i18n values verbatim and wraps them in a single-arg\n * `i18n({ _i18n: true, en: \"About\", pl: \"O nas\" })` call (see the dialect spec \u00A79). This\n * module implements that `i18n()` resolver plus the locale-context seam the future\n * `BaseLayout`/middleware will drive per route/locale.\n *\n * It reuses meno-core's primitives wholesale (`isI18nValue`, `resolveI18nValue`,\n * `extractLocaleFromPath`, `DEFAULT_I18N_CONFIG`) \u2014 no resolution logic is reinvented\n * here. The only new machinery is the `AsyncLocalStorage`-backed locale context.\n */\n\nimport { AsyncLocalStorage } from 'node:async_hooks';\nimport {\n  isI18nValue,\n  resolveI18nValue,\n  extractLocaleFromPath,\n  DEFAULT_I18N_CONFIG,\n} from 'meno-core/shared';\nimport type { I18nConfig, I18nValue } from 'meno-core/shared/types';\n\n/** The per-render locale context: the active locale + the project's i18n config. */\nexport interface LocaleContextValue {\n  locale: string;\n  config: I18nConfig;\n}\n\n// ---------------------------------------------------------------------------\n// Locale context store.\n//\n// SSR is concurrent: two requests for different locales can be in flight at once,\n// so a plain module variable would race. `AsyncLocalStorage` (node:async_hooks)\n// scopes the context to the async call tree of `runWithLocale`, so it survives the\n// `await` boundaries of an async render and every `i18n()` call in that tree reads\n// its own request's locale.\n//\n// ALS is a HARD dependency: it is unconditionally available in Node 18+ (this\n// package's build target) and in Bun, so we import it statically and `store` is\n// always defined. (An earlier version loaded it via `require('node:async_hooks')`\n// in a try/catch with a synchronous module-variable fallback. In the published ESM\n// bundle esbuild compiled that `require` to a shim that THREW, so the fallback took\n// over \u2014 and because it restored its variable synchronously, before the async\n// render promise resolved, every render leaked back to the default locale. The\n// static import removes that failure mode and the fallback entirely.)\n// ---------------------------------------------------------------------------\n\nconst store = new AsyncLocalStorage<LocaleContextValue>();\n\n/**\n * Run `fn` with `{ locale, config }` as the active locale context. This is the seam the\n * future `BaseLayout`/middleware calls once per route/locale; everything rendered inside\n * (and `i18n()` calls within it) sees this locale. Returns `fn`'s return value.\n */\nexport function runWithLocale<T>(\n  locale: string,\n  config: I18nConfig,\n  fn: () => T,\n): T {\n  return store.run({ locale, config }, fn);\n}\n\n/** Read the current locale context, or `undefined` if none is active. */\nexport function getLocaleContext(): LocaleContextValue | undefined {\n  return store.getStore();\n}\n\n// ---------------------------------------------------------------------------\n// Astro-global \u2192 locale derivation.\n// ---------------------------------------------------------------------------\n\n/** The slice of the Astro global this module reads. */\nexport interface AstroLike {\n  currentLocale?: string | null;\n  url?: { pathname?: string } | null;\n}\n\n/**\n * Derive the active locale from an Astro global:\n *   1. `astro.currentLocale` (Astro's own i18n routing answer), else\n *   2. the locale prefix on `astro.url.pathname` (e.g. `/pl/about` \u2192 `pl`), else\n *   3. `config.defaultLocale`.\n */\nexport function localeFromAstro(astro: AstroLike | null | undefined, config: I18nConfig): string {\n  if (astro?.currentLocale) return astro.currentLocale;\n  const pathname = astro?.url?.pathname;\n  if (typeof pathname === 'string') {\n    const { locale } = extractLocaleFromPath(pathname, config);\n    if (locale) return locale;\n  }\n  return config.defaultLocale;\n}\n\n// ---------------------------------------------------------------------------\n// i18n() \u2014 the emitter-facing resolver.\n// ---------------------------------------------------------------------------\n\n/**\n * Accepted second argument to `i18n()`. The single-arg call shape stays primary; this\n * override only narrows the locale/config when a caller already has them:\n *   - a bare locale string (`\"pl\"`),\n *   - `{ locale?, config? }`,\n *   - an Astro-like `{ currentLocale?, url? }` (normalized via `localeFromAstro`).\n */\nexport type I18nOverride =\n  | string\n  | { locale?: string; config?: I18nConfig }\n  | AstroLike;\n\n/** Resolve `override` (if any) to a concrete `{ locale, config }`, falling back to context/defaults. */\nfunction resolveLocaleAndConfig(override?: I18nOverride): LocaleContextValue {\n  const ctx = getLocaleContext();\n  const baseConfig = ctx?.config ?? DEFAULT_I18N_CONFIG;\n  const baseLocale = ctx?.locale ?? baseConfig.defaultLocale;\n\n  if (override === undefined) {\n    return { locale: baseLocale, config: baseConfig };\n  }\n\n  if (typeof override === 'string') {\n    return { locale: override, config: baseConfig };\n  }\n\n  // Plain { locale?, config? } override.\n  if ('locale' in override || 'config' in override) {\n    const config = override.config ?? baseConfig;\n    const locale = override.locale ?? ctx?.locale ?? config.defaultLocale;\n    return { locale, config };\n  }\n\n  // Astro-like override ({ currentLocale?, url? }).\n  const config = baseConfig;\n  return { locale: localeFromAstro(override as AstroLike, config), config };\n}\n\n/**\n * Resolve an i18n value to the active locale's string (or array, for list props).\n *\n * - Non-i18n values pass through unchanged (so the emitter can wrap any prop/attr/href\n *   value uniformly).\n * - i18n values resolve via meno-core's `resolveI18nValue` fallback chain\n *   (exact locale \u2192 defaultLocale \u2192 first available \u2192 empty string/array).\n * - Locale/config come from `override` if given, else the active `runWithLocale` context,\n *   else `DEFAULT_I18N_CONFIG`'s default locale \u2014 a no-context call never throws.\n *\n * Single-arg `i18n(value)` is the primary call shape; `override` is optional.\n */\nexport function i18n<V>(value: V, override?: I18nOverride): V extends I18nValue ? string | unknown[] : V;\nexport function i18n(value: unknown, override?: I18nOverride): unknown {\n  if (!isI18nValue(value)) return value;\n  const { locale, config } = resolveLocaleAndConfig(override);\n  return resolveI18nValue(value, locale, config);\n}\n", "/**\n * meno-astro \u2014 locale middleware factory.\n *\n * \u2500\u2500 Why middleware (and not BaseLayout) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n * In Astro, the `i18n(...)` calls in a *page body* execute in the page component's\n * render scope, NOT inside `BaseLayout`'s frontmatter \u2014 so BaseLayout cannot wrap them\n * in `runWithLocale`. Astro **middleware**, by contrast, wraps the whole page render per\n * request (SSR) / per prerender (static): `onRequest(context, next)` runs `next()` to\n * render the matched route, and anything we establish around that `next()` call is in\n * scope for the entire page + all its components.\n *\n * So the locale seam is: `onRequest = (ctx, next) =>\n *   runWithLocale(deriveLocale(ctx, config), config, () => next())`. The\n * `AsyncLocalStorage` context that `runWithLocale` opens is then read by every `i18n()`\n * call anywhere in that render tree (see `runtime/i18n.ts`).\n *\n * This module exports a **pure, testable factory** `createLocaleMiddleware(config)` plus\n * the `deriveLocale` policy it uses. The actual module Astro injects\n * (`runtime/localeMiddleware.ts`) wraps this factory, loading the project config once.\n *\n * \u2500\u2500 Typing without the `astro` dependency \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n * `meno-astro` does not (yet) depend on `astro`, and no Astro toolchain is wired into\n * this package's test/type-check. Rather than import `MiddlewareHandler` /\n * `APIContext` from `astro` (which would not resolve here), we type against a **minimal\n * structural slice** of Astro's documented middleware contract:\n *   - `context.currentLocale?: string`  \u2014 Astro's own i18n-routing answer.\n *   - `context.url?: URL`               \u2014 the request URL (for path-prefix fallback).\n *   - `next(): Promise<Response> | Response` \u2014 render the matched route.\n * Astro's real `MiddlewareHandler` is assignable to this shape, so the injected module\n * (`onRequest`) is correct-by-design against the documented API. The unit tests drive a\n * mock context with exactly this surface.\n */\n\nimport { runWithLocale, localeFromAstro } from './i18n';\nimport type { I18nConfig } from 'meno-core/shared/types';\n\n/**\n * The minimal slice of Astro's middleware `APIContext` this middleware reads.\n * Astro's real `APIContext` is structurally assignable to this.\n */\nexport interface LocaleMiddlewareContext {\n  /** Astro's resolved locale for the current route (from its native i18n routing). */\n  currentLocale?: string | null;\n  /** The request URL \u2014 used for the `/pl/\u2026` path-prefix fallback. */\n  url?: URL | { pathname?: string } | null;\n}\n\n/**\n * The minimal slice of Astro's `MiddlewareHandler` signature this factory returns.\n * `next` renders the matched route and yields its `Response`; the return value of the\n * handler is that same `Response`. Astro's real `MiddlewareHandler` is assignable here.\n */\nexport type LocaleMiddleware = (\n  context: LocaleMiddlewareContext,\n  next: () => Promise<Response> | Response,\n) => Promise<Response> | Response;\n\n/**\n * Derive the active locale for a request from its Astro context, against `config`:\n *   1. `context.currentLocale` \u2014 trust Astro's native i18n routing when it has an answer,\n *   2. else `localeFromAstro(context, config)` \u2014 the `/<locale>/\u2026` URL path-prefix\n *      (which itself falls back to `config.defaultLocale`),\n *   3. else `config.defaultLocale` \u2014 a final guard (e.g. a falsy `currentLocale` AND a\n *      missing/blank URL).\n *\n * Exported for direct unit testing of the policy in isolation.\n */\nexport function deriveLocale(context: LocaleMiddlewareContext, config: I18nConfig): string {\n  if (context?.currentLocale) return context.currentLocale;\n  // localeFromAstro reads `{ currentLocale, url: { pathname } }`; our context matches.\n  const fromAstro = localeFromAstro(context as { currentLocale?: string | null; url?: { pathname?: string } | null }, config);\n  return fromAstro || config.defaultLocale;\n}\n\n/**\n * Build a locale middleware bound to a concrete {@link I18nConfig}. The returned handler\n * derives the request's locale (via {@link deriveLocale}) and runs the rest of the render\n * (`next`) inside `runWithLocale(locale, config, \u2026)`, so every `i18n()` call in the page +\n * its components resolves to that locale.\n *\n * Pure and synchronous to construct (no filesystem / no Astro coupling), so a test can\n * call it with a mock `context` + mock `next` and assert end-to-end resolution.\n */\nexport function createLocaleMiddleware(config: I18nConfig): LocaleMiddleware {\n  return (context, next) => {\n    const locale = deriveLocale(context ?? {}, config);\n    return runWithLocale(locale, config, () => next());\n  };\n}\n"],
+  "mappings": ";;;;;;;;AAaA,SAAS,yBAAyB;AAkClC,IAAM,QAAQ,IAAI,kBAAsC;AAOjD,SAAS,cACd,QACA,QACA,IACG;AACH,SAAO,MAAM,IAAI,EAAE,QAAQ,OAAO,GAAG,EAAE;AACzC;AAGO,SAAS,mBAAmD;AACjE,SAAO,MAAM,SAAS;AACxB;AAkBO,SAAS,gBAAgB,OAAqC,QAA4B;AAC/F,MAAI,OAAO,cAAe,QAAO,MAAM;AACvC,QAAM,WAAW,OAAO,KAAK;AAC7B,MAAI,OAAO,aAAa,UAAU;AAChC,UAAM,EAAE,OAAO,IAAI,sBAAsB,UAAU,MAAM;AACzD,QAAI,OAAQ,QAAO;AAAA,EACrB;AACA,SAAO,OAAO;AAChB;AAmBA,SAAS,uBAAuB,UAA6C;AAC3E,QAAM,MAAM,iBAAiB;AAC7B,QAAM,aAAa,KAAK,UAAU;AAClC,QAAM,aAAa,KAAK,UAAU,WAAW;AAE7C,MAAI,aAAa,QAAW;AAC1B,WAAO,EAAE,QAAQ,YAAY,QAAQ,WAAW;AAAA,EAClD;AAEA,MAAI,OAAO,aAAa,UAAU;AAChC,WAAO,EAAE,QAAQ,UAAU,QAAQ,WAAW;AAAA,EAChD;AAGA,MAAI,YAAY,YAAY,YAAY,UAAU;AAChD,UAAMA,UAAS,SAAS,UAAU;AAClC,UAAM,SAAS,SAAS,UAAU,KAAK,UAAUA,QAAO;AACxD,WAAO,EAAE,QAAQ,QAAAA,QAAO;AAAA,EAC1B;AAGA,QAAM,SAAS;AACf,SAAO,EAAE,QAAQ,gBAAgB,UAAuB,MAAM,GAAG,OAAO;AAC1E;AAeO,SAAS,KAAK,OAAgB,UAAkC;AACrE,MAAI,CAAC,YAAY,KAAK,EAAG,QAAO;AAChC,QAAM,EAAE,QAAQ,OAAO,IAAI,uBAAuB,QAAQ;AAC1D,SAAO,iBAAiB,OAAO,QAAQ,MAAM;AAC/C;;;ACrFO,SAAS,aAAa,SAAkC,QAA4B;AACzF,MAAI,SAAS,cAAe,QAAO,QAAQ;AAE3C,QAAM,YAAY,gBAAgB,SAAkF,MAAM;AAC1H,SAAO,aAAa,OAAO;AAC7B;AAWO,SAAS,uBAAuB,QAAsC;AAC3E,SAAO,CAAC,SAAS,SAAS;AACxB,UAAM,SAAS,aAAa,WAAW,CAAC,GAAG,MAAM;AACjD,WAAO,cAAc,QAAQ,QAAQ,MAAM,KAAK,CAAC;AAAA,EACnD;AACF;",
+  "names": ["config"]
+}

package/dist/chunks/{chunk-V4SUAPTT.js → chunk-GITHFAZG.js}

@@ -1,6 +1,6 @@
 import {
   __esm
-} from "./chunk-ZYQNHI3W.js";
+} from "./chunk-5BVKIPKS.js";
 
 // ../core/lib/shared/constants.ts
 var SERVER_PORT, SERVE_PORT, NODE_TYPE;
@@ -1648,6 +1648,70 @@ function serializeValue(value) {
   return String(value);
 }
 
+// ../core/lib/shared/slugTranslator.ts
+function buildSlugIndex(mappings) {
+  const index = /* @__PURE__ */ new Map();
+  for (const mapping of mappings) {
+    for (const [locale, slug] of Object.entries(mapping.slugs)) {
+      const key = `${locale}:${slug}`;
+      index.set(key, {
+        pageId: mapping.pageId,
+        slugs: mapping.slugs
+      });
+    }
+  }
+  return index;
+}
+function findPageBySlug(slug, locale, index) {
+  const key = `${locale}:${slug}`;
+  return index.get(key);
+}
+function translatePath(currentPath, targetLocale, currentLocale, defaultLocale, index) {
+  let slug = currentPath;
+  if (slug.startsWith("/")) {
+    slug = slug.substring(1);
+  }
+  if (currentLocale !== defaultLocale) {
+    if (slug.startsWith(`${currentLocale}/`)) {
+      slug = slug.substring(currentLocale.length + 1);
+    } else if (slug === currentLocale) {
+      slug = "";
+    }
+  }
+  if (slug === "" || slug === "/") {
+    slug = "";
+  }
+  let entry = findPageBySlug(slug, currentLocale, index);
+  if (!entry && currentLocale !== defaultLocale) {
+    entry = findPageBySlug(slug, defaultLocale, index);
+  }
+  if (!entry) {
+    if (targetLocale === defaultLocale) {
+      return slug === "" ? "/" : `/${slug}`;
+    }
+    return slug === "" ? `/${targetLocale}` : `/${targetLocale}/${slug}`;
+  }
+  const targetSlug = entry.slugs[targetLocale] ?? entry.slugs[defaultLocale] ?? slug;
+  if (targetLocale === defaultLocale) {
+    return targetSlug === "" ? "/" : `/${targetSlug}`;
+  }
+  return targetSlug === "" ? `/${targetLocale}` : `/${targetLocale}/${targetSlug}`;
+}
+function getLocaleLinks(currentPath, currentLocale, i18nConfig, index) {
+  return i18nConfig.locales.map((localeConfig) => ({
+    locale: localeConfig.code,
+    langTag: localeConfig.langTag,
+    name: localeConfig.name,
+    nativeName: localeConfig.nativeName,
+    path: translatePath(currentPath, localeConfig.code, currentLocale, i18nConfig.defaultLocale, index),
+    isCurrent: localeConfig.code === currentLocale
+  }));
+}
+function resolveSlugToPageId(slug, locale, index) {
+  const entry = findPageBySlug(slug, locale, index);
+  return entry?.pageId;
+}
+
 // ../core/lib/shared/types/cms.ts
 var IRREGULAR_PLURALS = {
   categories: "category",
@@ -2580,6 +2644,74 @@ var specialValueMappings = {
   // Note: CSS functions (blur, translateY, scale, rotate, repeat) are now handled
   // dynamically in utilityClassMapper.ts - no need to hardcode specific values here
 };
+var classToStyleSpecialCases = {
+  f: { prop: "display", value: "flex" },
+  "fd-col": { prop: "flexDirection", value: "column" },
+  "fd-row": { prop: "flexDirection", value: "row" },
+  g: { prop: "display", value: "grid" },
+  b: { prop: "display", value: "block" },
+  i: { prop: "display", value: "inline" },
+  ib: { prop: "display", value: "inline-block" },
+  h: { prop: "display", value: "none" },
+  "if": { prop: "display", value: "inline-flex" },
+  ig: { prop: "display", value: "inline-grid" },
+  "jc-c": { prop: "justifyContent", value: "center" },
+  "jc-s": { prop: "justifyContent", value: "flex-start" },
+  "jc-e": { prop: "justifyContent", value: "flex-end" },
+  "jc-b": { prop: "justifyContent", value: "space-between" },
+  "jc-a": { prop: "justifyContent", value: "space-around" },
+  "jc-ev": { prop: "justifyContent", value: "space-evenly" },
+  "ai-c": { prop: "alignItems", value: "center" },
+  "ai-s": { prop: "alignItems", value: "flex-start" },
+  "ai-e": { prop: "alignItems", value: "flex-end" },
+  "ai-st": { prop: "alignItems", value: "stretch" },
+  "ai-b": { prop: "alignItems", value: "baseline" },
+  "o-h": { prop: "overflow", value: "hidden" },
+  "o-a": { prop: "overflow", value: "auto" },
+  "o-s": { prop: "overflow", value: "scroll" },
+  "o-v": { prop: "overflow", value: "visible" },
+  "cursor-pointer": { prop: "cursor", value: "pointer" },
+  "cursor-default": { prop: "cursor", value: "default" },
+  "pe-none": { prop: "pointerEvents", value: "none" },
+  "pe-auto": { prop: "pointerEvents", value: "auto" },
+  "us-none": { prop: "userSelect", value: "none" },
+  "us-auto": { prop: "userSelect", value: "auto" },
+  "us-text": { prop: "userSelect", value: "text" },
+  "us-all": { prop: "userSelect", value: "all" },
+  "whs-normal": { prop: "whiteSpace", value: "normal" },
+  "whs-nowrap": { prop: "whiteSpace", value: "nowrap" },
+  "whs-pre": { prop: "whiteSpace", value: "pre" },
+  "whs-pre-wrap": { prop: "whiteSpace", value: "pre-wrap" },
+  "whs-pre-line": { prop: "whiteSpace", value: "pre-line" },
+  // Grid template columns
+  "gtc-2": { prop: "gridTemplateColumns", value: "repeat(2, 1fr)" },
+  "gtc-3": { prop: "gridTemplateColumns", value: "repeat(3, 1fr)" },
+  "gtc-4": { prop: "gridTemplateColumns", value: "repeat(4, 1fr)" },
+  "gtc-5": { prop: "gridTemplateColumns", value: "repeat(5, 1fr)" },
+  "gtc-6": { prop: "gridTemplateColumns", value: "repeat(6, 1fr)" },
+  // Backdrop filter
+  "bdf-blur-4": { prop: "backdropFilter", value: "blur(4px)" },
+  "bdf-blur-8": { prop: "backdropFilter", value: "blur(8px)" },
+  "bdf-blur-10": { prop: "backdropFilter", value: "blur(10px)" },
+  // Transform
+  "tm-ty-0": { prop: "transform", value: "translateY(0)" },
+  "tm-ty-n10": { prop: "transform", value: "translateY(-10px)" },
+  "tm-ty-n50p": { prop: "transform", value: "translateY(-50%)" },
+  // Filter
+  "flt-blur-1": { prop: "filter", value: "blur(1px)" },
+  // Shadow presets (reverse mapping)
+  "sh-0": { prop: "boxShadow", value: "none" },
+  "sh-1": { prop: "boxShadow", value: "0 1px 2px rgba(0, 0, 0, 0.05)" },
+  "sh-2": { prop: "boxShadow", value: "0 4px 12px rgba(0, 0, 0, 0.1)" },
+  "sh-3": { prop: "boxShadow", value: "0 8px 24px rgba(0, 0, 0, 0.15)" },
+  "sh-4": { prop: "boxShadow", value: "0 12px 32px rgba(0, 0, 0, 0.2)" },
+  // Gradient presets (reverse mapping)
+  "gr-1": { prop: "background", value: "linear-gradient(90deg, rgba(10,22,40,0.85) 0%, rgba(10,22,40,0.2) 100%)" },
+  "gr-2": { prop: "background", value: "linear-gradient(0deg, #a9e8fd, #00aee8 25%, #0f1335 72%)" },
+  // Border presets (reverse mapping)
+  "bd-0": { prop: "border", value: "1px solid var(--border)" },
+  "bd-1": { prop: "border", value: "1px solid var(--border-light)" }
+};
 var shadowPresets = {
   "0": "none",
   "1": "0 1px 2px rgba(0, 0, 0, 0.05)",
@@ -3834,6 +3966,41 @@ function responsiveStylesToClasses(styles, options) {
   }
   return classes;
 }
+function classToStyle(className) {
+  let cleanClass = className;
+  let responsivePrefix = "";
+  if (className.startsWith("t-")) {
+    responsivePrefix = "t";
+    cleanClass = className.slice(2);
+  } else if (className.startsWith("mob-")) {
+    responsivePrefix = "mob";
+    cleanClass = className.slice(4);
+  }
+  if (classToStyleSpecialCases[cleanClass]) {
+    return classToStyleSpecialCases[cleanClass];
+  }
+  const match = cleanClass.match(/^([a-z-]+)-(.*?)$/);
+  if (!match) return null;
+  const [, prefix, value] = match;
+  let prop = "";
+  for (const [key, val] of Object.entries(propertyMap)) {
+    if (val === prefix) {
+      prop = key;
+      break;
+    }
+  }
+  if (!prop) return null;
+  if (/^h[0-9a-z]+$/.test(value)) {
+    const registered = getStyleValue(cleanClass);
+    if (registered != null) {
+      return { prop, value: String(registered) };
+    }
+  }
+  if (value.includes("background") || value.includes("text") || value.includes("border")) {
+    return { prop, value: `var(--${value})` };
+  }
+  return { prop, value };
+}
 
 // ../core/lib/shared/elementClassName.ts
 function shortHash2(input) {
@@ -4083,6 +4250,7 @@ export {
   generateUtilityCSS,
   generateInteractiveCSS,
   responsiveStylesToClasses,
+  classToStyle,
   shortHash2 as shortHash,
   DEFAULT_I18N_CONFIG,
   migrateI18nConfig,
@@ -4096,10 +4264,14 @@ export {
   serializeSortExpression,
   parseFilterExpression,
   serializeFilterExpression,
+  buildSlugIndex,
+  translatePath,
+  getLocaleLinks,
+  resolveSlugToPageId,
   fontFaceCss,
   fontPreloadLinks,
   mergeLibraries,
   generateLibraryTags,
   filterLibrariesByContext
 };
-//# sourceMappingURL=chunk-V4SUAPTT.js.map
+//# sourceMappingURL=chunk-GITHFAZG.js.map