@ariaui/shadow 0.1.4 → 0.1.6

package/dist/tokens.cjs

@@ -0,0 +1,665 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// tokens.ts
+var tokens_exports = {};
+__export(tokens_exports, {
+  ELEVATION_PRESETS: () => ELEVATION_PRESETS,
+  addLayer: () => addLayer,
+  buildRing: () => buildRing,
+  colorRing: () => colorRing,
+  colorShadow: () => colorShadow,
+  createElevationScale: () => createElevationScale,
+  createErrorRing: () => createErrorRing,
+  createFocusRing: () => createFocusRing,
+  createLayer: () => createLayer,
+  createShadow: () => createShadow,
+  getElevationLevels: () => getElevationLevels,
+  insetLayer: () => insetLayer,
+  interpolateElevation: () => interpolateElevation,
+  layerToString: () => layerToString,
+  mergeShadows: () => mergeShadows,
+  multiplyAlpha: () => multiplyAlpha,
+  offsetLayer: () => offsetLayer,
+  parseLayer: () => parseLayer,
+  parseShadow: () => parseShadow,
+  removeLayer: () => removeLayer,
+  resolveAllShadows: () => resolveAllShadows,
+  resolveDarkMultiplier: () => resolveDarkMultiplier,
+  resolveFocusRing: () => resolveFocusRing,
+  resolveLayerAlphas: () => resolveLayerAlphas,
+  resolveShadow: () => resolveShadow,
+  scaleLayer: () => scaleLayer,
+  scaleShadow: () => scaleShadow,
+  setLayerColor: () => setLayerColor,
+  setLayerOpacity: () => setLayerOpacity,
+  stepElevation: () => stepElevation,
+  toBoxShadow: () => toBoxShadow,
+  toCSSDeclaration: () => toCSSDeclaration,
+  toCSSProperties: () => toCSSProperties,
+  toTailwindClass: () => toTailwindClass,
+  withFocusRing: () => withFocusRing
+});
+module.exports = __toCommonJS(tokens_exports);
+
+// src/parse.ts
+function parseShadow(css) {
+  const trimmed = css.trim();
+  if (!trimmed || trimmed === "none") {
+    return { layers: [] };
+  }
+  const layers = splitShadowLayers(trimmed).map(parseLayer);
+  return { layers };
+}
+function parseLayer(css) {
+  var _a, _b, _c, _d;
+  const trimmed = css.trim();
+  const inset = trimmed.startsWith("inset ");
+  const rest = inset ? trimmed.slice(6).trim() : trimmed;
+  const { values, colorStr } = extractParts(rest);
+  const color = parseColorToOklch(colorStr);
+  return {
+    offsetX: (_a = values[0]) != null ? _a : "0px",
+    offsetY: (_b = values[1]) != null ? _b : "0px",
+    blur: (_c = values[2]) != null ? _c : "0px",
+    spread: (_d = values[3]) != null ? _d : "0px",
+    color,
+    inset
+  };
+}
+function splitShadowLayers(css) {
+  const layers = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < css.length; i++) {
+    const ch = css[i];
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    else if (ch === "," && depth === 0) {
+      layers.push(css.slice(start, i).trim());
+      start = i + 1;
+    }
+  }
+  const last = css.slice(start).trim();
+  if (last) layers.push(last);
+  return layers;
+}
+function extractParts(str) {
+  const funcMatch = str.match(/(rgba?\(.+?\)|oklch\(.+?\)|hsla?\(.+?\))\s*$/i);
+  if (funcMatch) {
+    const colorStr = funcMatch[1];
+    const before = str.slice(0, str.length - funcMatch[0].length).trim();
+    return { values: before.split(/\s+/), colorStr };
+  }
+  const parts = str.split(/\s+/);
+  const isLength = (s) => /^-?[\d.]/.test(s);
+  let colorIdx = parts.length;
+  for (let i = parts.length - 1; i >= 0; i--) {
+    if (isLength(parts[i])) {
+      colorIdx = i + 1;
+      break;
+    }
+  }
+  if (colorIdx < parts.length) {
+    return {
+      values: parts.slice(0, colorIdx),
+      colorStr: parts.slice(colorIdx).join(" ")
+    };
+  }
+  if (!isLength(parts[0])) {
+    return {
+      values: parts.slice(1),
+      colorStr: parts[0]
+    };
+  }
+  return { values: parts, colorStr: "black" };
+}
+function parseColorToOklch(color) {
+  const c = color.trim().toLowerCase();
+  if (c.startsWith("oklch(")) {
+    const inner = c.slice(6, -1).trim();
+    const [colorPart, alphaPart] = inner.split("/").map((s) => s.trim());
+    const parts = colorPart.split(/\s+/);
+    let l = parseFloat(parts[0]);
+    if (parts[0].endsWith("%")) l = l / 100;
+    return {
+      l,
+      c: parseFloat(parts[1]) || 0,
+      h: parseFloat(parts[2]) || 0,
+      alpha: alphaPart !== void 0 ? parseFloat(alphaPart) : 1
+    };
+  }
+  if (c.startsWith("rgb")) {
+    const inner = c.replace(/rgba?\(/, "").replace(")", "").trim();
+    let r, g, b, a;
+    if (inner.includes("/")) {
+      const [colorPart, alphaPart] = inner.split("/").map((s) => s.trim());
+      const parts = colorPart.split(/[\s,]+/).map(Number);
+      [r, g, b] = parts;
+      a = parseFloat(alphaPart);
+    } else {
+      const parts = inner.split(/[\s,]+/).map(Number);
+      r = parts[0];
+      g = parts[1];
+      b = parts[2];
+      a = parts.length > 3 ? parts[3] : 1;
+    }
+    return srgbToOklchSimple(r / 255, g / 255, b / 255, a);
+  }
+  if (c.startsWith("#")) {
+    let h = c.slice(1);
+    if (h.length === 3) h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+    if (h.length === 4)
+      h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2] + h[3] + h[3];
+    const r = parseInt(h.slice(0, 2), 16) / 255;
+    const g = parseInt(h.slice(2, 4), 16) / 255;
+    const b = parseInt(h.slice(4, 6), 16) / 255;
+    const a = h.length === 8 ? parseInt(h.slice(6, 8), 16) / 255 : 1;
+    return srgbToOklchSimple(r, g, b, a);
+  }
+  if (c === "black") return { l: 0, c: 0, h: 0, alpha: 1 };
+  if (c === "white") return { l: 1, c: 0, h: 0, alpha: 1 };
+  if (c === "transparent") return { l: 0, c: 0, h: 0, alpha: 0 };
+  return { l: 0, c: 0, h: 0, alpha: 0 };
+}
+function srgbToOklchSimple(r, g, b, alpha) {
+  const toLinear = (c) => c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+  const lr = toLinear(r);
+  const lg = toLinear(g);
+  const lb = toLinear(b);
+  const l = 0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb;
+  const m = 0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb;
+  const s = 0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb;
+  const l_ = Math.cbrt(l);
+  const m_ = Math.cbrt(m);
+  const s_ = Math.cbrt(s);
+  const L = 0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_;
+  const a = 1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_;
+  const bLab = 0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_;
+  const chroma = Math.sqrt(a * a + bLab * bLab);
+  let hue = Math.atan2(bLab, a) * 180 / Math.PI;
+  if (hue < 0) hue += 360;
+  if (chroma < 1e-8) hue = 0;
+  return { l: L, c: chroma, h: hue, alpha };
+}
+
+// src/layer.ts
+var DEFAULTS = {
+  offsetX: "0px",
+  offsetY: "0px",
+  blur: "0px",
+  spread: "0px",
+  color: { l: 0, c: 0, h: 0, alpha: 0.1 },
+  inset: false
+};
+function createLayer(config = {}) {
+  return __spreadValues(__spreadValues({}, DEFAULTS), config);
+}
+function scaleLayer(layer, factor) {
+  return __spreadProps(__spreadValues({}, layer), {
+    offsetX: scalePx(layer.offsetX, factor),
+    offsetY: scalePx(layer.offsetY, factor),
+    blur: scalePx(layer.blur, factor),
+    spread: scalePx(layer.spread, factor)
+  });
+}
+function setLayerColor(layer, color) {
+  return __spreadProps(__spreadValues({}, layer), { color });
+}
+function setLayerOpacity(layer, alpha) {
+  return __spreadProps(__spreadValues({}, layer), {
+    color: __spreadProps(__spreadValues({}, layer.color), { alpha: clamp(alpha, 0, 1) })
+  });
+}
+function offsetLayer(layer, offset) {
+  var _a, _b;
+  return __spreadProps(__spreadValues({}, layer), {
+    offsetX: (_a = offset.x) != null ? _a : layer.offsetX,
+    offsetY: (_b = offset.y) != null ? _b : layer.offsetY
+  });
+}
+function insetLayer(layer, inset) {
+  return __spreadProps(__spreadValues({}, layer), { inset: inset != null ? inset : !layer.inset });
+}
+function scalePx(value, factor) {
+  const n = parseFloat(value);
+  if (Number.isNaN(n)) return value;
+  const scaled = Math.round(n * factor * 100) / 100;
+  return `${scaled}px`;
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+// src/compose.ts
+function createShadow(...layers) {
+  return { layers };
+}
+function addLayer(shadow, layer) {
+  return { layers: [...shadow.layers, layer] };
+}
+function removeLayer(shadow, index) {
+  return {
+    layers: shadow.layers.filter((_, i) => i !== index)
+  };
+}
+function mergeShadows(...shadows) {
+  return {
+    layers: shadows.flatMap((s) => s.layers)
+  };
+}
+function scaleShadow(shadow, factor) {
+  return {
+    layers: shadow.layers.map((layer) => scaleLayer(layer, factor))
+  };
+}
+function colorShadow(shadow, color, preserveAlpha = true) {
+  return {
+    layers: shadow.layers.map((layer) => {
+      const newColor = preserveAlpha ? __spreadProps(__spreadValues({}, color), { alpha: layer.color.alpha }) : color;
+      return setLayerColor(layer, newColor);
+    })
+  };
+}
+function multiplyAlpha(shadow, factor) {
+  return {
+    layers: shadow.layers.map((layer) => __spreadProps(__spreadValues({}, layer), {
+      color: __spreadProps(__spreadValues({}, layer.color), {
+        alpha: Math.max(0, Math.min(1, layer.color.alpha * factor))
+      })
+    }))
+  };
+}
+
+// src/elevation.ts
+var GEOMETRY = {
+  xs: [
+    ["0px", "1px", "2px", "0px", 0.051]
+  ],
+  sm: [
+    ["0px", "1px", "3px", "0px", 0.102],
+    ["0px", "1px", "2px", "-1px", 0.102]
+  ],
+  md: [
+    ["0px", "4px", "6px", "-1px", 0.102],
+    ["0px", "2px", "4px", "-2px", 0.059]
+  ],
+  lg: [
+    ["0px", "12px", "16px", "-4px", 0.078],
+    ["0px", "4px", "6px", "-2px", 0.031],
+    ["0px", "2px", "2px", "-1px", 0.039]
+  ],
+  xl: [
+    ["0px", "20px", "24px", "-4px", 0.078],
+    ["0px", "8px", "8px", "-4px", 0.031],
+    ["0px", "3px", "3px", "-1.5px", 0.039]
+  ],
+  "2xl": [
+    ["0px", "24px", "48px", "-12px", 0.18],
+    ["0px", "4px", "4px", "-2px", 0.039]
+  ],
+  "3xl": [
+    ["0px", "32px", "64px", "-12px", 0.141],
+    ["0px", "5px", "5px", "-2.5px", 0.039]
+  ]
+};
+var LEVEL_ORDER = [
+  "none",
+  "xs",
+  "sm",
+  "md",
+  "lg",
+  "xl",
+  "2xl",
+  "3xl"
+];
+function buildLayers(geometries, baseColor, alphaMultiplier) {
+  return geometries.map(([offsetX, offsetY, blur, spread, alpha]) => ({
+    offsetX,
+    offsetY,
+    blur,
+    spread,
+    color: __spreadProps(__spreadValues({}, baseColor), {
+      alpha: Math.max(0, Math.min(1, alpha * alphaMultiplier))
+    }),
+    inset: false
+  }));
+}
+var BLACK = { l: 0, c: 0, h: 0, alpha: 1 };
+var ELEVATION_PRESETS = Object.fromEntries(
+  LEVEL_ORDER.map((level) => {
+    if (level === "none") return [level, { layers: [] }];
+    return [level, { layers: buildLayers(GEOMETRY[level], BLACK, 1) }];
+  })
+);
+function createElevationScale(config) {
+  var _a, _b;
+  const color = (_a = config == null ? void 0 : config.color) != null ? _a : BLACK;
+  const multiplier = (_b = config == null ? void 0 : config.alphaMultiplier) != null ? _b : 1;
+  return Object.fromEntries(
+    LEVEL_ORDER.map((level) => {
+      if (level === "none") return [level, { layers: [] }];
+      return [level, { layers: buildLayers(GEOMETRY[level], color, multiplier) }];
+    })
+  );
+}
+function interpolateElevation(from, to, t) {
+  const clamped = Math.max(0, Math.min(1, t));
+  const count = Math.min(from.layers.length, to.layers.length);
+  if (count === 0) {
+    return { layers: [] };
+  }
+  const layers = [];
+  for (let i = 0; i < count; i++) {
+    const a = from.layers[i];
+    const b = to.layers[i];
+    layers.push({
+      offsetX: lerpPx(a.offsetX, b.offsetX, clamped),
+      offsetY: lerpPx(a.offsetY, b.offsetY, clamped),
+      blur: lerpPx(a.blur, b.blur, clamped),
+      spread: lerpPx(a.spread, b.spread, clamped),
+      color: {
+        l: lerp(a.color.l, b.color.l, clamped),
+        c: lerp(a.color.c, b.color.c, clamped),
+        h: lerpHue(a.color.h, b.color.h, clamped),
+        alpha: lerp(a.color.alpha, b.color.alpha, clamped)
+      },
+      inset: clamped < 0.5 ? a.inset : b.inset
+    });
+  }
+  return { layers };
+}
+function stepElevation(current, direction) {
+  const idx = LEVEL_ORDER.indexOf(current);
+  if (idx === -1) return current;
+  const next = direction === "up" ? idx + 1 : idx - 1;
+  const clamped = Math.max(0, Math.min(LEVEL_ORDER.length - 1, next));
+  return LEVEL_ORDER[clamped];
+}
+function getElevationLevels() {
+  return LEVEL_ORDER;
+}
+function lerp(a, b, t) {
+  return Math.round((a + (b - a) * t) * 1e4) / 1e4;
+}
+function lerpPx(a, b, t) {
+  const na = parseFloat(a) || 0;
+  const nb = parseFloat(b) || 0;
+  const result = Math.round((na + (nb - na) * t) * 100) / 100;
+  return `${result}px`;
+}
+function lerpHue(a, b, t) {
+  let dh = b - a;
+  if (dh > 180) dh -= 360;
+  if (dh < -180) dh += 360;
+  let h = a + dh * t;
+  return (h % 360 + 360) % 360;
+}
+
+// src/ring.ts
+var DEFAULT_RING = {
+  ringWidth: "2px",
+  ringOffset: "2px",
+  // brand-500 (violet): "60.6% 0.219 293"
+  ringColor: { l: 0.606, c: 0.219, h: 293, alpha: 1 },
+  // white background
+  bgColor: { l: 1, c: 0, h: 0, alpha: 1 }
+};
+var DEFAULT_ERROR_RING = {
+  ringWidth: "2px",
+  ringOffset: "2px",
+  // red-500: "63.7% 0.208 25"
+  ringColor: { l: 0.637, c: 0.208, h: 25, alpha: 1 },
+  bgColor: { l: 1, c: 0, h: 0, alpha: 1 }
+};
+function createFocusRing(config) {
+  const ring = __spreadValues(__spreadValues({}, DEFAULT_RING), config);
+  return buildRing(ring);
+}
+function createErrorRing(config) {
+  const ring = __spreadValues(__spreadValues({}, DEFAULT_ERROR_RING), config);
+  return buildRing(ring);
+}
+function buildRing(config) {
+  const offsetStr = config.ringOffset;
+  const totalStr = addPx(config.ringOffset, config.ringWidth);
+  const gapLayer = {
+    offsetX: "0px",
+    offsetY: "0px",
+    blur: "0px",
+    spread: offsetStr,
+    color: config.bgColor,
+    inset: false
+  };
+  const ringLayer = {
+    offsetX: "0px",
+    offsetY: "0px",
+    blur: "0px",
+    spread: totalStr,
+    color: config.ringColor,
+    inset: false
+  };
+  return { layers: [gapLayer, ringLayer] };
+}
+function withFocusRing(shadow, ring) {
+  return { layers: [...ring.layers, ...shadow.layers] };
+}
+function colorRing(ringColor) {
+  return createFocusRing({ ringColor });
+}
+function addPx(a, b) {
+  const na = parseFloat(a) || 0;
+  const nb = parseFloat(b) || 0;
+  return `${na + nb}px`;
+}
+
+// src/format.ts
+var import_color = require("@ariaui/color");
+function layerToString(layer) {
+  const parts = [];
+  if (layer.inset) parts.push("inset");
+  parts.push(layer.offsetX, layer.offsetY, layer.blur, layer.spread);
+  parts.push((0, import_color.toOklchString)(layer.color));
+  return parts.join(" ");
+}
+function toBoxShadow(shadow) {
+  if (shadow.layers.length === 0) return "none";
+  return shadow.layers.map(layerToString).join(", ");
+}
+function toCSSProperties(shadow) {
+  return { boxShadow: toBoxShadow(shadow) };
+}
+function toTailwindClass(shadow) {
+  if (shadow.layers.length === 0) return "shadow-none";
+  const value = shadow.layers.map((layer) => {
+    const parts = [];
+    if (layer.inset) parts.push("inset");
+    parts.push(layer.offsetX, layer.offsetY, layer.blur, layer.spread);
+    parts.push(formatOklchCompact(layer.color));
+    return parts.join("_");
+  }).join(",");
+  return `shadow-[${value}]`;
+}
+function toCSSDeclaration(shadow) {
+  return `box-shadow: ${toBoxShadow(shadow)};`;
+}
+function formatOklchCompact(color) {
+  const l = `${round(color.l * 100, 2)}%`;
+  const c = round(color.c, 4);
+  const h = round(color.h, 2);
+  if (color.alpha < 1) {
+    return `oklch(${l}_${c}_${h}/${round(color.alpha, 3)})`;
+  }
+  return `oklch(${l}_${c}_${h})`;
+}
+function round(value, decimals) {
+  const f = Math.pow(10, decimals);
+  return Math.round(value * f) / f;
+}
+
+// src/resolve.ts
+var import_tokens = require("@ariaui/tokens");
+var SHADOW_GEOMETRY = {
+  xs: [["0px", "1px", "2px", "0px"]],
+  sm: [["0px", "1px", "3px", "0px"], ["0px", "1px", "2px", "-1px"]],
+  md: [["0px", "4px", "6px", "-1px"], ["0px", "2px", "4px", "-2px"]],
+  lg: [["0px", "12px", "16px", "-4px"], ["0px", "4px", "6px", "-2px"], ["0px", "2px", "2px", "-1px"]],
+  xl: [["0px", "20px", "24px", "-4px"], ["0px", "8px", "8px", "-4px"], ["0px", "3px", "3px", "-1.5px"]],
+  "2xl": [["0px", "24px", "48px", "-12px"], ["0px", "4px", "4px", "-2px"]],
+  "3xl": [["0px", "32px", "64px", "-12px"], ["0px", "5px", "5px", "-2.5px"]]
+};
+var DEPTH_KEYS = {
+  xs: ["shadow-xs-depth-1"],
+  sm: ["shadow-sm-depth-1", "shadow-sm-depth-2"],
+  md: ["shadow-md-depth-1", "shadow-md-depth-2"],
+  lg: ["shadow-lg-depth-1", "shadow-lg-depth-2", "shadow-lg-depth-3"],
+  xl: ["shadow-xl-depth-1", "shadow-xl-depth-2", "shadow-xl-depth-3"],
+  "2xl": ["shadow-2xl-depth-1", "shadow-2xl-depth-2"],
+  "3xl": ["shadow-3xl-depth-1", "shadow-3xl-depth-2"]
+};
+function extractAlpha(tokenValue) {
+  const match = tokenValue.match(/\/\s*([\d.]+)\s*\)/);
+  if (match) return parseFloat(match[1]);
+  return 0;
+}
+function resolveBlack() {
+  const channels = import_tokens.base["black"];
+  return { l: 0, c: 0, h: 0, alpha: 1 };
+}
+function resolveShadow(level, mode = "light") {
+  if (level === "none") return { layers: [] };
+  const geometry = SHADOW_GEOMETRY[level];
+  const depthKeys = DEPTH_KEYS[level];
+  const map = mode === "dark" ? import_tokens.dark : import_tokens.light;
+  const baseColor = resolveBlack();
+  const layers = geometry.map((geo, i) => {
+    var _a, _b;
+    const depthKey = depthKeys[i];
+    const tokenValue = (_b = (_a = map[depthKey]) != null ? _a : import_tokens.light[depthKey]) != null ? _b : "";
+    const alpha = extractAlpha(tokenValue);
+    return {
+      offsetX: geo[0],
+      offsetY: geo[1],
+      blur: geo[2],
+      spread: geo[3],
+      color: __spreadProps(__spreadValues({}, baseColor), { alpha }),
+      inset: false
+    };
+  });
+  return { layers };
+}
+function resolveAllShadows(mode = "light") {
+  const levels = ["none", "xs", "sm", "md", "lg", "xl", "2xl", "3xl"];
+  return Object.fromEntries(
+    levels.map((level) => [level, resolveShadow(level, mode)])
+  );
+}
+function resolveFocusRing(variant = "default") {
+  var _a, _b;
+  const ringWidth = (_a = import_tokens.light["ring-width"]) != null ? _a : "2px";
+  const ringOffset = (_b = import_tokens.light["ring-offset"]) != null ? _b : "2px";
+  const ringColorKey = variant === "error" ? "focus-ring-error-color" : "focus-ring-color";
+  const ringColorRef = import_tokens.light[ringColorKey];
+  const bgColor = { l: 1, c: 0, h: 0, alpha: 1 };
+  let ringColor;
+  if (variant === "error") {
+    ringColor = { l: 0.637, c: 0.208, h: 25, alpha: 1 };
+  } else {
+    ringColor = { l: 0.606, c: 0.219, h: 293, alpha: 1 };
+  }
+  return { ringWidth, ringOffset, ringColor, bgColor };
+}
+function resolveLayerAlphas(level, mode = "light") {
+  if (level === "none") return [];
+  const depthKeys = DEPTH_KEYS[level];
+  const map = mode === "dark" ? import_tokens.dark : import_tokens.light;
+  return depthKeys.map((key) => {
+    var _a, _b;
+    const value = (_b = (_a = map[key]) != null ? _a : import_tokens.light[key]) != null ? _b : "";
+    return extractAlpha(value);
+  });
+}
+function resolveDarkMultiplier(level) {
+  if (level === "none") return 1;
+  const lightAlphas = resolveLayerAlphas(level, "light");
+  const darkAlphas = resolveLayerAlphas(level, "dark");
+  if (lightAlphas.length === 0) return 1;
+  let totalRatio = 0;
+  for (let i = 0; i < lightAlphas.length; i++) {
+    if (lightAlphas[i] > 0) {
+      totalRatio += darkAlphas[i] / lightAlphas[i];
+    }
+  }
+  return Math.round(totalRatio / lightAlphas.length * 1e3) / 1e3;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ELEVATION_PRESETS,
+  addLayer,
+  buildRing,
+  colorRing,
+  colorShadow,
+  createElevationScale,
+  createErrorRing,
+  createFocusRing,
+  createLayer,
+  createShadow,
+  getElevationLevels,
+  insetLayer,
+  interpolateElevation,
+  layerToString,
+  mergeShadows,
+  multiplyAlpha,
+  offsetLayer,
+  parseLayer,
+  parseShadow,
+  removeLayer,
+  resolveAllShadows,
+  resolveDarkMultiplier,
+  resolveFocusRing,
+  resolveLayerAlphas,
+  resolveShadow,
+  scaleLayer,
+  scaleShadow,
+  setLayerColor,
+  setLayerOpacity,
+  stepElevation,
+  toBoxShadow,
+  toCSSDeclaration,
+  toCSSProperties,
+  toTailwindClass,
+  withFocusRing
+});