@kbach/react 1.0.0-beta.28 → 1.0.0-beta.29

package/dist/{chunk-KTRJZDVE.mjs → chunk-NHWKWY2T.mjs}

@@ -1,14 +1,16 @@
 import {
   resolveKbachConfig
-} from "./chunk-43FOLRQA.mjs";
+} from "./chunk-UK5S55DF.mjs";
 import {
   buildResetCSS,
-  defaultTheme
-} from "./chunk-OVKVZA7B.mjs";
+  colorVariablesCss,
+  defaultTheme,
+  withColorVariables
+} from "./chunk-FBYS4BI3.mjs";
 
 // src/vite-plugin/index.ts
 import { readFileSync as readFileSync3, writeFileSync, mkdirSync, existsSync, statSync as statSync2 } from "fs";
-import { join as join4, dirname } from "path";
+import { join as join4, dirname, basename } from "path";
 import { pathToFileURL } from "url";
 import { createRequire } from "module";
 
@@ -184,6 +186,8 @@ function formatKbachCSS(tokenRules, theme, usedTags) {
   lines.push("", ":root {", `  --kb-dark-mode: ${theme.darkMode};`);
   for (const [varName, val] of declarations) lines.push(`  ${varName}: ${val};`);
   lines.push("}");
+  const colorVars = colorVariablesCss(theme);
+  if (colorVars) lines.push("", prettifyCSS(colorVars));
   lines.push("", prettifyCSS(text));
   return lines.join("\n");
 }
@@ -211,10 +215,13 @@ import { readFileSync as readFileSync2 } from "fs";
 import { join as join3 } from "path";
 
 // src/vite-plugin/wasmNode.ts
-import { generate_css } from "@kbach/core-engine/node";
+import { generate_css, suggest_class } from "@kbach/core-engine/node";
 function generateCssForToken(token, themeJson) {
   return JSON.parse(generate_css(token, themeJson));
 }
+function suggestClassForToken(token, themeJson) {
+  return suggest_class(token, themeJson) || null;
+}
 
 // src/vite-plugin/scan.ts
 import { readdirSync, readFileSync, statSync } from "fs";
@@ -474,17 +481,18 @@ function isMarkerClass(base) {
   if (slashIdx === -1) return false;
   return MARKER_CLASSES.has(base.slice(0, slashIdx)) && slashIdx < base.length - 1;
 }
-function warnIfUnknownClass(token, filePath, code, isResolvable, projectCssClasses, warnedTokens) {
+var TAILWIND_SHADE = /-(?:50|[1-9]00|950)(?:\/|$)/;
+function warnIfUnknownClass(token, filePath, code, isResolvable, projectCssClasses, warnedTokens, suggest) {
   if (isResolvable || warnedTokens.has(token)) return;
   const base = stripModifierPrefix(token);
   if (!base || projectCssClasses.has(base) || isMarkerClass(base)) return;
   warnedTokens.add(token);
   const pos = findLineCol(code, token);
   const location = pos ? `${blue(filePath)}${green(`:${pos.line}:${pos.column}`)}` : blue(filePath);
-  console.warn(
-    `${kbachTag()} ${gray("Unknown class")} ${highlight(token)} ${gray("\u2014 no Kbach utility or project CSS rule matches it. Typo?")}
-  ${bold("at")} ${location}`
-  );
+  const suggestion = suggest?.(token) ?? null;
+  const hint = suggestion ? `${gray("\u2014 did you mean")} ${highlight(suggestion)}${gray("?")}${TAILWIND_SHADE.test(token) ? gray(" Kbach color shades run 1\u201312, not 50\u2013950.") : ""}` : gray("\u2014 no Kbach utility or project CSS rule matches it. Typo?");
+  console.warn(`${kbachTag()} ${gray("Unknown class")} ${highlight(token)} ${hint}
+  ${bold("at")} ${location}`);
 }
 
 // src/staticCss/engine.ts
@@ -494,7 +502,8 @@ function normPath(p) {
 }
 var SAFELIST_KEY = "\0kbach-safelist";
 function createKbachStaticCssEngine(options) {
-  const { root, theme, themeJson, includeDirs, safelist } = options;
+  const { root, theme, includeDirs, safelist } = options;
+  const themeJson = JSON.stringify(withColorVariables(theme));
   const fileTokens = /* @__PURE__ */ new Map();
   const tokenRules = /* @__PURE__ */ new Map();
   const fileTags = /* @__PURE__ */ new Map();
@@ -512,7 +521,7 @@ function createKbachStaticCssEngine(options) {
       tokens.add(tok);
       const rules = resolveToken(tok);
       if (process.env.NODE_ENV !== "production") {
-        warnIfUnknownClass(tok, filePath, code, rules.length > 0, projectCssClasses, warnedTokens);
+        warnIfUnknownClass(tok, filePath, code, rules.length > 0, projectCssClasses, warnedTokens, (t) => suggestClassForToken(t, themeJson));
       }
     }
     fileTokens.set(normPath(filePath), tokens);
@@ -597,13 +606,27 @@ function isEsmRequireFailure(err) {
   return err.code === "ERR_REQUIRE_ESM" || /is not defined in ES module scope/.test(err.message);
 }
 async function importConfigModule(path) {
-  const mod = await import(pathToFileURL(path).href);
+  const url = pathToFileURL(path).href;
+  let mod;
+  try {
+    mod = await nativeImport(url + "?t=" + Date.now());
+  } catch (err) {
+    if (err.code !== "ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING") throw err;
+    mod = await import(url);
+  }
   return mod.default ?? mod;
 }
+var nativeImport = new Function("url", "return import(url)");
 function requireConfigModule(root, path) {
-  const mod = createRequire(root)(path);
+  const req = createRequire(root);
+  delete req.cache[req.resolve(path)];
+  const mod = req(path);
   return mod.default ?? mod;
 }
+function isConfigFile(root, file) {
+  const norm = (p) => p.replace(/\\/g, "/").toLowerCase();
+  return /^kbach\.config\.(c|m)?js$/.test(basename(file)) && norm(dirname(file)) === norm(root);
+}
 async function loadConfigFile(root) {
   const cjsPath = join4(root, "kbach.config.cjs");
   if (existsSync(cjsPath)) return requireConfigModule(root, cjsPath);
@@ -611,6 +634,7 @@ async function loadConfigFile(root) {
   if (existsSync(mjsPath)) return importConfigModule(mjsPath);
   const jsPath = join4(root, "kbach.config.js");
   if (!existsSync(jsPath)) return void 0;
+  if (isEsmProject(root)) return importConfigModule(jsPath);
   try {
     return requireConfigModule(root, jsPath);
   } catch (err) {
@@ -618,6 +642,13 @@ async function loadConfigFile(root) {
     return importConfigModule(jsPath);
   }
 }
+function isEsmProject(root) {
+  try {
+    return JSON.parse(readFileSync3(join4(root, "package.json"), "utf-8")).type === "module";
+  } catch {
+    return false;
+  }
+}
 async function resolveEffectiveTheme(root, options) {
   if (options.theme) return options.theme;
   if (options.config) return resolveKbachConfig(options.config);
@@ -629,7 +660,7 @@ function kbach(options = {}) {
   const safelist = options.safelist ?? [];
   let root = process.cwd();
   let theme = defaultTheme;
-  let engine = createKbachStaticCssEngine({ root, theme, themeJson: JSON.stringify(theme), includeDirs, safelist });
+  let engine = createKbachStaticCssEngine({ root, theme, includeDirs, safelist });
   let mainCSSFilePath = join4(root, "src", "kbach.css");
   function mainCSSFile() {
     return mainCSSFilePath;
@@ -646,13 +677,27 @@ function kbach(options = {}) {
       syncMainCSSFile(server);
     }, CSS_SYNC_DEBOUNCE_MS);
   }
+  async function reloadConfig(server) {
+    if (options.theme || options.config) return;
+    try {
+      theme = await resolveEffectiveTheme(root, options);
+    } catch (err) {
+      console.warn(`${kbachTag()} Couldn't reload kbach.config: ${err.message}`);
+      return;
+    }
+    engine = createKbachStaticCssEngine({ root, theme, includeDirs, safelist });
+    engine.scanProjectCssSelectorsOnce();
+    engine.initialScan();
+    engine.processSafelist();
+    syncMainCSSFile(server);
+  }
   return {
     name: "kbach",
     enforce: "pre",
     async configResolved(resolved) {
       root = resolved.root;
       theme = await resolveEffectiveTheme(root, options);
-      engine = createKbachStaticCssEngine({ root, theme, themeJson: JSON.stringify(theme), includeDirs, safelist });
+      engine = createKbachStaticCssEngine({ root, theme, includeDirs, safelist });
       mainCSSFilePath = findMainCSSFile(root, includeDirs, options.cssFile);
     },
     buildStart() {
@@ -667,6 +712,10 @@ function kbach(options = {}) {
     configureServer(server) {
       const onAddOrUnlink = (file, isUnlink) => {
         if (file.includes("node_modules")) return;
+        if (isConfigFile(root, file)) {
+          void reloadConfig(server);
+          return;
+        }
         if (!/\.(tsx?|jsx?)$/.test(file)) return;
         if (isUnlink) {
           engine.removeFile(file);
@@ -682,8 +731,12 @@ function kbach(options = {}) {
       server.watcher.on("add", (file) => onAddOrUnlink(file, false));
       server.watcher.on("unlink", (file) => onAddOrUnlink(file, true));
     },
-    handleHotUpdate({ file, server }) {
+    async handleHotUpdate({ file, server }) {
       if (file.includes("node_modules")) return;
+      if (isConfigFile(root, file)) {
+        await reloadConfig(server);
+        return;
+      }
       if (!/\.(tsx?|jsx?)$/.test(file)) return;
       try {
         engine.processFile(file, readSourceFile(file));
@@ -704,6 +757,7 @@ export {
   findMainCSSFile,
   DEFAULT_SCAN_DIRS,
   CSS_SYNC_DEBOUNCE_MS,
+  isConfigFile,
   loadConfigFile,
   resolveEffectiveTheme,
   kbach

package/dist/{chunk-43FOLRQA.mjs → chunk-UK5S55DF.mjs}

@@ -2,8 +2,9 @@ import {
   defaultTheme,
   detectDarkModeStrategyFromDom,
   getTheme,
+  parseHexRgb,
   setTheme
-} from "./chunk-OVKVZA7B.mjs";
+} from "./chunk-FBYS4BI3.mjs";
 
 // src/darkModeStore.ts
 var STORAGE_KEY = "kbach-theme";
@@ -97,56 +98,6 @@ function seedDefaultMode(fallback) {
   notify();
 }
 
-// src/colorVariables.ts
-function parseHexRgb(hex) {
-  const m = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(hex.trim());
-  if (!m) return null;
-  let h = m[1];
-  if (h.length === 3) h = h.split("").map((c) => c + c).join("");
-  const n = parseInt(h, 16);
-  return [n >> 16 & 255, n >> 8 & 255, n & 255];
-}
-function wrapDarkDecls(strategy, decls) {
-  switch (strategy) {
-    case "class":
-      return `.dark { ${decls} }`;
-    case "media":
-      return `@media (prefers-color-scheme: dark) { :root { ${decls} } }`;
-    case "attribute":
-    default:
-      return `[data-theme="dark"] { ${decls} }`;
-  }
-}
-var STYLE_ID = "kbach-colors";
-var injectedForTheme = null;
-function ensureColorVariablesInjected(theme) {
-  if (typeof document === "undefined") return;
-  if (injectedForTheme === theme) return;
-  injectedForTheme = theme;
-  const lightDecls = [];
-  const darkDecls = [];
-  for (const [name, value] of Object.entries(theme.colors)) {
-    if (typeof value === "string") continue;
-    const light = parseHexRgb(value.light);
-    const dark = parseHexRgb(value.dark);
-    if (!light || !dark) continue;
-    lightDecls.push(`--kb-color-${name}: ${light.join(",")};`);
-    darkDecls.push(`--kb-color-${name}: ${dark.join(",")};`);
-  }
-  let el = document.getElementById(STYLE_ID);
-  if (lightDecls.length === 0) {
-    el?.remove();
-    return;
-  }
-  if (!el) {
-    el = document.createElement("style");
-    el.id = STYLE_ID;
-    document.head.insertBefore(el, document.head.firstChild);
-  }
-  el.textContent = `:root { ${lightDecls.join(" ")} }
-${wrapDarkDecls(theme.darkMode, darkDecls.join(" "))}`;
-}
-
 // src/config.ts
 function applyOpacityToHex(hex, opacityText) {
   const rgb = parseHexRgb(hex);
@@ -156,7 +107,13 @@ function applyOpacityToHex(hex, opacityText) {
   return `rgba(${rgb.join(",")},${clamped})`;
 }
 function resolveColorEntry(value, lookup) {
-  if (typeof value !== "string") return value;
+  if (typeof value !== "string") {
+    const side = (v, mode2) => {
+      const r = resolveColorEntry(v, lookup);
+      return typeof r === "string" ? r : r[mode2];
+    };
+    return { light: side(value.light, "light"), dark: side(value.dark, "dark") };
+  }
   const slash = value.indexOf("/");
   const name = slash === -1 ? value : value.slice(0, slash);
   const opacity = slash === -1 ? void 0 : value.slice(slash + 1);
@@ -221,8 +178,6 @@ function applyKbachConfig(config) {
 }
 
 export {
-  parseHexRgb,
-  ensureColorVariablesInjected,
   getGlobalDarkMode,
   getGlobalThemeMode,
   setGlobalThemeMode,

package/dist/index.d.mts

@@ -16,7 +16,13 @@ declare function isRuntimeCSSDisabled(): boolean;
 /**
  * Resolves a Kbach class string via the Rust/WASM engine, cascade-order-safe
  * injects the resulting CSS rules into a single `<style data-kbach>` tag,
- * and returns the class string unchanged for use as `className`.
+ * and returns the class string to use as `className` (the input, except
+ * for a mode-aware color whose values aren't hex, which the engine still
+ * expands into per-mode classes).
+ *
+ * Classes the page's static kbach.css already defines are left to it (see
+ * `staticClasses`), and mode-aware colors use the same CSS variables as the
+ * static build (see `refreshEngineTheme`), so kb() and kbach.css agree.
  *
  * Must be called after `await initKbach()` resolves — see wasmLoader.ts.
  */

package/dist/index.d.ts

@@ -16,7 +16,13 @@ declare function isRuntimeCSSDisabled(): boolean;
 /**
  * Resolves a Kbach class string via the Rust/WASM engine, cascade-order-safe
  * injects the resulting CSS rules into a single `<style data-kbach>` tag,
- * and returns the class string unchanged for use as `className`.
+ * and returns the class string to use as `className` (the input, except
+ * for a mode-aware color whose values aren't hex, which the engine still
+ * expands into per-mode classes).
+ *
+ * Classes the page's static kbach.css already defines are left to it (see
+ * `staticClasses`), and mode-aware colors use the same CSS variables as the
+ * static build (see `refreshEngineTheme`), so kb() and kbach.css agree.
  *
  * Must be called after `await initKbach()` resolves — see wasmLoader.ts.
  */

package/dist/index.js

@@ -467,6 +467,78 @@ function detectDarkModeStrategyFromDom() {
   setTheme({ ...activeTheme, darkMode: raw });
 }
 
+// src/colorVariables.ts
+function parseHexRgb(hex) {
+  const m = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(hex.trim());
+  if (!m) return null;
+  let h = m[1];
+  if (h.length === 3) h = h.split("").map((c) => c + c).join("");
+  const n = parseInt(h, 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+function wrapDarkDecls(strategy, decls) {
+  switch (strategy) {
+    case "class":
+      return `.dark { ${decls} }`;
+    case "media":
+      return `@media (prefers-color-scheme: dark) { :root { ${decls} } }`;
+    case "attribute":
+    default:
+      return `[data-theme="dark"] { ${decls} }`;
+  }
+}
+function modeAwareDecls(theme) {
+  const light = [];
+  const dark = [];
+  for (const [name, value] of Object.entries(theme.colors)) {
+    if (typeof value === "string") continue;
+    const l = parseHexRgb(value.light);
+    const d = parseHexRgb(value.dark);
+    if (!l || !d) continue;
+    light.push(`--kb-color-${name}: ${l.join(",")};`);
+    dark.push(`--kb-color-${name}: ${d.join(",")};`);
+  }
+  return { light, dark };
+}
+function colorVariablesCss(theme) {
+  const { light, dark } = modeAwareDecls(theme);
+  if (light.length === 0) return "";
+  return `:root { ${light.join(" ")} }
+${wrapDarkDecls(theme.darkMode, dark.join(" "))}`;
+}
+function withColorVariables(theme) {
+  let changed = false;
+  const colors = {};
+  for (const [name, value] of Object.entries(theme.colors)) {
+    if (typeof value !== "string" && parseHexRgb(value.light) && parseHexRgb(value.dark)) {
+      colors[name] = `rgb(var(--kb-color-${name}))`;
+      changed = true;
+    } else {
+      colors[name] = value;
+    }
+  }
+  return changed ? { ...theme, colors } : theme;
+}
+var STYLE_ID = "kbach-colors";
+var injectedForTheme = null;
+function ensureColorVariablesInjected(theme) {
+  if (typeof document === "undefined") return;
+  if (injectedForTheme === theme) return;
+  injectedForTheme = theme;
+  const css = colorVariablesCss(theme);
+  let el = document.getElementById(STYLE_ID);
+  if (!css) {
+    el?.remove();
+    return;
+  }
+  if (!el) {
+    el = document.createElement("style");
+    el.id = STYLE_ID;
+    document.head.insertBefore(el, document.head.firstChild);
+  }
+  el.textContent = css;
+}
+
 // src/reset.ts
 var RESET_STYLE_ID = "kbach-reset";
 var RESET_RULES = [
@@ -601,27 +673,88 @@ function ensureResetInjected() {
 var KB_CACHE_MAX = 500;
 var kbCache = /* @__PURE__ */ new Map();
 var cachedForThemeJson = null;
+var engineThemeJson = "";
+var hasModeAware = false;
+function refreshEngineTheme() {
+  const theme = getTheme();
+  const withVars = withColorVariables(theme);
+  hasModeAware = withVars !== theme;
+  engineThemeJson = hasModeAware ? JSON.stringify(withVars) : getThemeJson();
+}
+var staticOwner = null;
+var staticSheet = null;
+var staticRuleCount = -1;
+var staticTokens = /* @__PURE__ */ new Set();
+function unescapeCssIdent(s) {
+  return s.replace(/\\([0-9a-fA-F]{1,6})\s?/g, (_, hex) => String.fromCodePoint(parseInt(hex, 16))).replace(/\\(.)/g, "$1");
+}
+function isStaticKbachSheet(sheet) {
+  try {
+    return Array.from(sheet.cssRules).some((r) => r instanceof CSSStyleRule && r.selectorText === ":root" && r.cssText.includes("--kb-dark-mode"));
+  } catch {
+    return false;
+  }
+}
+function collectClasses(rules, into) {
+  for (const r of Array.from(rules)) {
+    if (r instanceof CSSStyleRule) {
+      for (const m of r.selectorText.matchAll(/\.((?:\\[0-9a-fA-F]{1,6}\s?|\\.|[\w-])+)/g)) into.add(unescapeCssIdent(m[1]));
+    } else if ("cssRules" in r) {
+      collectClasses(r.cssRules, into);
+    }
+  }
+}
+function staticClasses() {
+  if (typeof document === "undefined") return staticTokens;
+  let sheet = staticOwner && staticOwner.sheet;
+  if (!sheet || !isStaticKbachSheet(sheet)) {
+    sheet = Array.from(document.styleSheets).find((s) => s !== styleEl?.sheet && isStaticKbachSheet(s)) ?? null;
+    staticOwner = sheet?.ownerNode ?? null;
+  }
+  if (!sheet) {
+    staticSheet = null;
+    staticTokens = /* @__PURE__ */ new Set();
+    return staticTokens;
+  }
+  if (sheet !== staticSheet || sheet.cssRules.length !== staticRuleCount) {
+    staticSheet = sheet;
+    staticRuleCount = sheet.cssRules.length;
+    staticTokens = /* @__PURE__ */ new Set();
+    collectClasses(sheet.cssRules, staticTokens);
+  }
+  return staticTokens;
+}
 function kb(classString) {
   const themeJson = getThemeJson();
   if (themeJson !== cachedForThemeJson) {
     kbCache.clear();
     cachedForThemeJson = themeJson;
+    refreshEngineTheme();
+  }
+  const statics = runtimeCSSDisabled ? null : staticClasses();
+  let toResolve = classString;
+  let alreadyStatic = "";
+  if (statics && statics.size > 0) {
+    const tokens = classString.split(/\s+/).filter(Boolean);
+    toResolve = tokens.filter((t) => !statics.has(t)).join(" ");
+    alreadyStatic = tokens.filter((t) => statics.has(t)).join(" ");
   }
-  let result = kbCache.get(classString);
+  let result = kbCache.get(toResolve);
   if (result === void 0) {
-    const json = generateCss(classString, themeJson);
+    const json = generateCss(toResolve, engineThemeJson);
     result = JSON.parse(json);
     if (kbCache.size >= KB_CACHE_MAX) kbCache.clear();
-    kbCache.set(classString, result);
+    kbCache.set(toResolve, result);
   }
   const { className, rules } = result;
   if (!runtimeCSSDisabled) {
     ensureResetInjected();
+    if (hasModeAware) ensureColorVariablesInjected(getTheme());
     for (const { rule, order } of rules) {
       injectRule(rule, order);
     }
   }
-  return className;
+  return alreadyStatic ? (alreadyStatic + " " + className).trim() : className;
 }
 
 // src/KbachReset.tsx
@@ -631,56 +764,6 @@ function KbachReset() {
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("style", { id: RESET_STYLE_ID, children: BASE_RESET });
 }
 
-// src/colorVariables.ts
-function parseHexRgb(hex) {
-  const m = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(hex.trim());
-  if (!m) return null;
-  let h = m[1];
-  if (h.length === 3) h = h.split("").map((c) => c + c).join("");
-  const n = parseInt(h, 16);
-  return [n >> 16 & 255, n >> 8 & 255, n & 255];
-}
-function wrapDarkDecls(strategy, decls) {
-  switch (strategy) {
-    case "class":
-      return `.dark { ${decls} }`;
-    case "media":
-      return `@media (prefers-color-scheme: dark) { :root { ${decls} } }`;
-    case "attribute":
-    default:
-      return `[data-theme="dark"] { ${decls} }`;
-  }
-}
-var STYLE_ID = "kbach-colors";
-var injectedForTheme = null;
-function ensureColorVariablesInjected(theme) {
-  if (typeof document === "undefined") return;
-  if (injectedForTheme === theme) return;
-  injectedForTheme = theme;
-  const lightDecls = [];
-  const darkDecls = [];
-  for (const [name, value] of Object.entries(theme.colors)) {
-    if (typeof value === "string") continue;
-    const light = parseHexRgb(value.light);
-    const dark = parseHexRgb(value.dark);
-    if (!light || !dark) continue;
-    lightDecls.push(`--kb-color-${name}: ${light.join(",")};`);
-    darkDecls.push(`--kb-color-${name}: ${dark.join(",")};`);
-  }
-  let el = document.getElementById(STYLE_ID);
-  if (lightDecls.length === 0) {
-    el?.remove();
-    return;
-  }
-  if (!el) {
-    el = document.createElement("style");
-    el.id = STYLE_ID;
-    document.head.insertBefore(el, document.head.firstChild);
-  }
-  el.textContent = `:root { ${lightDecls.join(" ")} }
-${wrapDarkDecls(theme.darkMode, darkDecls.join(" "))}`;
-}
-
 // src/darkModeStore.ts
 var STORAGE_KEY = "kbach-theme";
 var listeners = /* @__PURE__ */ new Set();
@@ -782,7 +865,13 @@ function applyOpacityToHex(hex, opacityText) {
   return `rgba(${rgb.join(",")},${clamped})`;
 }
 function resolveColorEntry(value, lookup) {
-  if (typeof value !== "string") return value;
+  if (typeof value !== "string") {
+    const side = (v, mode2) => {
+      const r = resolveColorEntry(v, lookup);
+      return typeof r === "string" ? r : r[mode2];
+    };
+    return { light: side(value.light, "light"), dark: side(value.dark, "dark") };
+  }
   const slash = value.indexOf("/");
   const name = slash === -1 ? value : value.slice(0, slash);
   const opacity = slash === -1 ? void 0 : value.slice(slash + 1);

package/dist/index.mjs

@@ -4,26 +4,26 @@ import {
   isKbachReady,
   isRuntimeCSSDisabled,
   kb
-} from "./chunk-DJKDEDPE.mjs";
+} from "./chunk-K6AUD64N.mjs";
 import {
   applyKbachConfig,
-  ensureColorVariablesInjected,
   getGlobalDarkMode,
   getGlobalThemeMode,
-  parseHexRgb,
   resolveKbachConfig,
   seedDefaultMode,
   setGlobalThemeMode,
   subscribeGlobalDarkMode,
   toggleGlobalDarkMode
-} from "./chunk-43FOLRQA.mjs";
+} from "./chunk-UK5S55DF.mjs";
 import {
   BASE_RESET,
   RESET_STYLE_ID,
   defaultTheme,
+  ensureColorVariablesInjected,
   getTheme,
+  parseHexRgb,
   setTheme
-} from "./chunk-OVKVZA7B.mjs";
+} from "./chunk-FBYS4BI3.mjs";
 
 // src/KbachReset.tsx
 import { jsx } from "react/jsx-runtime";