@ariaui/radius 0.1.1

package/dist/tokens.cjs

@@ -0,0 +1,454 @@
+"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, {
+  BREAKPOINTS: () => BREAKPOINTS,
+  clampScale: () => clampScale,
+  createLinearScale: () => createLinearScale,
+  createScale: () => createScale,
+  innerCorners: () => innerCorners,
+  innerRadius: () => innerRadius,
+  mobileRadius: () => mobileRadius,
+  nestingPair: () => nestingPair,
+  parseCorners: () => parseCorners,
+  parseRadius: () => parseRadius,
+  requiredGap: () => requiredGap,
+  resolveBaseRadius: () => resolveBaseRadius,
+  resolveInnerRadius: () => resolveInnerRadius,
+  resolveRadius: () => resolveRadius,
+  resolveRadiusScale: () => resolveRadiusScale,
+  resolveThemeAliases: () => resolveThemeAliases,
+  responsiveRadius: () => responsiveRadius,
+  roundCorners: () => roundCorners,
+  scaleBy: () => scaleBy,
+  setBottom: () => setBottom,
+  setCorner: () => setCorner,
+  setLeft: () => setLeft,
+  setRight: () => setRight,
+  setTop: () => setTop,
+  sortedBreakpoints: () => sortedBreakpoints,
+  sortedLevels: () => sortedLevels,
+  stepRadius: () => stepRadius,
+  toCSS: () => toCSS,
+  toCSSDeclaration: () => toCSSDeclaration,
+  toCSSProperties: () => toCSSProperties,
+  toCSSShorthand: () => toCSSShorthand,
+  toCSSVar: () => toCSSVar,
+  toPx: () => toPx2,
+  toRem: () => toRem,
+  toTailwindClass: () => toTailwindClass,
+  toTailwindCorners: () => toTailwindCorners,
+  uniformCorners: () => uniformCorners
+});
+module.exports = __toCommonJS(tokens_exports);
+
+// src/parse.ts
+function parseRadius(input) {
+  if (typeof input === "number") {
+    return { value: input, unit: "px", original: `${input}px` };
+  }
+  const trimmed = input.trim();
+  if (trimmed.endsWith("rem")) {
+    const value2 = parseFloat(trimmed);
+    if (Number.isNaN(value2)) throw new Error(`Invalid radius value: "${input}"`);
+    return { value: value2, unit: "rem", original: trimmed };
+  }
+  if (trimmed.endsWith("%")) {
+    const value2 = parseFloat(trimmed);
+    if (Number.isNaN(value2)) throw new Error(`Invalid radius value: "${input}"`);
+    return { value: value2, unit: "%", original: trimmed };
+  }
+  const value = parseFloat(trimmed);
+  if (Number.isNaN(value)) throw new Error(`Invalid radius value: "${input}"`);
+  return { value, unit: "px", original: trimmed.endsWith("px") ? trimmed : `${value}px` };
+}
+function parseCorners(input) {
+  const parts = input.trim().split(/\s+/);
+  if (parts.length === 1) {
+    const v = parseRadius(parts[0]);
+    return { topLeft: v, topRight: v, bottomRight: v, bottomLeft: v };
+  }
+  if (parts.length === 2) {
+    const tlbr = parseRadius(parts[0]);
+    const trbl = parseRadius(parts[1]);
+    return { topLeft: tlbr, topRight: trbl, bottomRight: tlbr, bottomLeft: trbl };
+  }
+  if (parts.length === 3) {
+    const tl = parseRadius(parts[0]);
+    const trbl = parseRadius(parts[1]);
+    const br = parseRadius(parts[2]);
+    return { topLeft: tl, topRight: trbl, bottomRight: br, bottomLeft: trbl };
+  }
+  if (parts.length >= 4) {
+    return {
+      topLeft: parseRadius(parts[0]),
+      topRight: parseRadius(parts[1]),
+      bottomRight: parseRadius(parts[2]),
+      bottomLeft: parseRadius(parts[3])
+    };
+  }
+  throw new Error(`Invalid border-radius shorthand: "${input}"`);
+}
+
+// src/scale.ts
+function createLinearScale(base = 0, step = 4, count = 6) {
+  const result = {};
+  for (let i = 0; i < count; i++) {
+    const value = base + step * i;
+    result[String(i)] = parseRadius(value);
+  }
+  return result;
+}
+function createScale(values) {
+  const result = {};
+  for (const [name, value] of Object.entries(values)) {
+    result[name] = parseRadius(value);
+  }
+  return result;
+}
+function scaleBy(scale, factor) {
+  const result = {};
+  for (const [name, rv] of Object.entries(scale)) {
+    const newValue = round(rv.value * factor);
+    result[name] = {
+      value: newValue,
+      unit: rv.unit,
+      original: `${newValue}${rv.unit}`
+    };
+  }
+  return result;
+}
+function clampScale(scale, min, max) {
+  const result = {};
+  for (const [name, rv] of Object.entries(scale)) {
+    const clamped = Math.max(min, Math.min(max, rv.value));
+    result[name] = {
+      value: clamped,
+      unit: rv.unit,
+      original: `${clamped}${rv.unit}`
+    };
+  }
+  return result;
+}
+function sortedLevels(scale) {
+  return Object.keys(scale).sort((a, b) => {
+    return toPx(scale[a]) - toPx(scale[b]);
+  });
+}
+function stepRadius(scale, current, direction) {
+  const ordered = sortedLevels(scale);
+  const idx = ordered.indexOf(current);
+  if (idx === -1) return current;
+  const next = direction === "up" ? idx + 1 : idx - 1;
+  const clamped = Math.max(0, Math.min(ordered.length - 1, next));
+  return ordered[clamped];
+}
+function round(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function toPx(rv) {
+  if (rv.unit === "rem") return rv.value * 16;
+  return rv.value;
+}
+
+// src/corners.ts
+function toRadiusValue(input) {
+  if (typeof input === "object" && "value" in input) return input;
+  return parseRadius(input);
+}
+var ZERO = { value: 0, unit: "px", original: "0px" };
+function uniformCorners(radius) {
+  const v = toRadiusValue(radius);
+  return { topLeft: v, topRight: v, bottomRight: v, bottomLeft: v };
+}
+function setCorner(corners, corner, value) {
+  return __spreadProps(__spreadValues({}, corners), { [corner]: toRadiusValue(value) });
+}
+function setTop(corners, value) {
+  const v = toRadiusValue(value);
+  return __spreadProps(__spreadValues({}, corners), { topLeft: v, topRight: v });
+}
+function setBottom(corners, value) {
+  const v = toRadiusValue(value);
+  return __spreadProps(__spreadValues({}, corners), { bottomLeft: v, bottomRight: v });
+}
+function setLeft(corners, value) {
+  const v = toRadiusValue(value);
+  return __spreadProps(__spreadValues({}, corners), { topLeft: v, bottomLeft: v });
+}
+function setRight(corners, value) {
+  const v = toRadiusValue(value);
+  return __spreadProps(__spreadValues({}, corners), { topRight: v, bottomRight: v });
+}
+function roundCorners(radius, ...corners) {
+  const v = toRadiusValue(radius);
+  return {
+    topLeft: corners.includes("topLeft") ? v : ZERO,
+    topRight: corners.includes("topRight") ? v : ZERO,
+    bottomRight: corners.includes("bottomRight") ? v : ZERO,
+    bottomLeft: corners.includes("bottomLeft") ? v : ZERO
+  };
+}
+
+// src/nesting.ts
+function toRadiusValue2(input) {
+  if (typeof input === "object" && "value" in input) return input;
+  return parseRadius(input);
+}
+function innerRadius(outer, gap) {
+  const o = toRadiusValue2(outer);
+  const inner = Math.max(0, o.value - gap);
+  return {
+    value: inner,
+    unit: o.unit,
+    original: `${inner}${o.unit}`
+  };
+}
+function innerCorners(outer, gap) {
+  return {
+    topLeft: innerRadius(outer.topLeft, gap),
+    topRight: innerRadius(outer.topRight, gap),
+    bottomRight: innerRadius(outer.bottomRight, gap),
+    bottomLeft: innerRadius(outer.bottomLeft, gap)
+  };
+}
+function requiredGap(outer, inner) {
+  const o = toRadiusValue2(outer);
+  const i = toRadiusValue2(inner);
+  return Math.max(0, o.value - i.value);
+}
+function nestingPair(outerRadius, gap) {
+  const outer = parseRadius(outerRadius);
+  const inner = innerRadius(outer, gap);
+  return { outer, inner };
+}
+
+// src/responsive.ts
+var BREAKPOINTS = {
+  sm: 640,
+  md: 768,
+  lg: 1024,
+  xl: 1280,
+  "2xl": 1536
+};
+function responsiveRadius(config, breakpoints = BREAKPOINTS) {
+  const defaultEntry = config["default"];
+  if (defaultEntry === void 0) {
+    throw new Error('responsiveRadius: "default" entry is required');
+  }
+  const defaultValue = parseRadius(defaultEntry);
+  const bps = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (key === "default") continue;
+    if (!(key in breakpoints)) {
+      throw new Error(
+        `responsiveRadius: unknown breakpoint "${key}". Available: ${Object.keys(breakpoints).join(", ")}`
+      );
+    }
+    bps[key] = parseRadius(value);
+  }
+  return { default: defaultValue, breakpoints: bps };
+}
+function mobileRadius(value, factor = 0.75) {
+  const scaled = Math.max(0, Math.round(value.value * factor));
+  return {
+    value: scaled,
+    unit: value.unit,
+    original: `${scaled}${value.unit}`
+  };
+}
+function sortedBreakpoints(responsive, breakpoints = BREAKPOINTS) {
+  return Object.entries(responsive.breakpoints).map(
+    ([name, value]) => {
+      var _a;
+      return [name, (_a = breakpoints[name]) != null ? _a : 0, value];
+    }
+  ).sort((a, b) => a[1] - b[1]);
+}
+
+// src/format.ts
+function round2(value, decimals = 4) {
+  const f = Math.pow(10, decimals);
+  return Math.round(value * f) / f;
+}
+function toCSS(value) {
+  return `${value.value}${value.unit}`;
+}
+function toRem(value, base = 16) {
+  if (value.unit === "rem") return `${value.value}rem`;
+  if (value.unit === "%") return value.original;
+  const rem = round2(value.value / base);
+  return `${rem}rem`;
+}
+function toPx2(value, base = 16) {
+  if (value.unit === "px") return `${value.value}px`;
+  if (value.unit === "%") return value.original;
+  const px = round2(value.value * base);
+  return `${px}px`;
+}
+function toCSSShorthand(corners) {
+  const tl = toCSS(corners.topLeft);
+  const tr = toCSS(corners.topRight);
+  const br = toCSS(corners.bottomRight);
+  const bl = toCSS(corners.bottomLeft);
+  if (tl === tr && tr === br && br === bl) return tl;
+  if (tl === br && tr === bl) return `${tl} ${tr}`;
+  if (tr === bl) return `${tl} ${tr} ${br}`;
+  return `${tl} ${tr} ${br} ${bl}`;
+}
+function toCSSProperties(corners) {
+  return {
+    borderTopLeftRadius: toCSS(corners.topLeft),
+    borderTopRightRadius: toCSS(corners.topRight),
+    borderBottomRightRadius: toCSS(corners.bottomRight),
+    borderBottomLeftRadius: toCSS(corners.bottomLeft)
+  };
+}
+function toCSSDeclaration(corners) {
+  return `border-radius: ${toCSSShorthand(corners)};`;
+}
+function toTailwindClass(value) {
+  return `rounded-[${toCSS(value)}]`;
+}
+function toTailwindCorners(corners) {
+  const tl = toCSS(corners.topLeft);
+  const tr = toCSS(corners.topRight);
+  const br = toCSS(corners.bottomRight);
+  const bl = toCSS(corners.bottomLeft);
+  if (tl === tr && tr === br && br === bl) {
+    return `rounded-[${tl}]`;
+  }
+  return [
+    `rounded-tl-[${tl}]`,
+    `rounded-tr-[${tr}]`,
+    `rounded-br-[${br}]`,
+    `rounded-bl-[${bl}]`
+  ].join(" ");
+}
+function toCSSVar(level) {
+  return `var(--radius-${level})`;
+}
+
+// src/resolve.ts
+var import_tokens = require("@ariaui/tokens");
+var RADIUS_KEYS = {
+  none: "radius-none",
+  xxs: "radius-xxs",
+  xs: "radius-xs",
+  sm: "radius-sm",
+  md: "radius-md",
+  lg: "radius-lg",
+  xl: "radius-xl",
+  "2xl": "radius-2xl",
+  "3xl": "radius-3xl",
+  "4xl": "radius-4xl",
+  full: "radius-full"
+};
+function resolveRadius(level) {
+  const tokenKey = RADIUS_KEYS[level];
+  const tokenValue = import_tokens.light[tokenKey];
+  if (tokenValue === void 0) {
+    throw new Error(`Radius token not found: "${level}" (key: "${tokenKey}")`);
+  }
+  return parseRadius(tokenValue);
+}
+function resolveRadiusScale() {
+  const result = {};
+  for (const level of Object.keys(RADIUS_KEYS)) {
+    result[level] = resolveRadius(level);
+  }
+  return result;
+}
+function resolveBaseRadius() {
+  const value = import_tokens.light["radius"];
+  if (value === void 0) {
+    throw new Error('Base radius token "radius" not found');
+  }
+  return parseRadius(value);
+}
+function resolveThemeAliases() {
+  return {
+    lg: "var(--radius)",
+    md: "calc(var(--radius) - 2px)",
+    sm: "calc(var(--radius) - 4px)"
+  };
+}
+function resolveInnerRadius(level, gap) {
+  const outer = resolveRadius(level);
+  return innerRadius(outer, gap);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BREAKPOINTS,
+  clampScale,
+  createLinearScale,
+  createScale,
+  innerCorners,
+  innerRadius,
+  mobileRadius,
+  nestingPair,
+  parseCorners,
+  parseRadius,
+  requiredGap,
+  resolveBaseRadius,
+  resolveInnerRadius,
+  resolveRadius,
+  resolveRadiusScale,
+  resolveThemeAliases,
+  responsiveRadius,
+  roundCorners,
+  scaleBy,
+  setBottom,
+  setCorner,
+  setLeft,
+  setRight,
+  setTop,
+  sortedBreakpoints,
+  sortedLevels,
+  stepRadius,
+  toCSS,
+  toCSSDeclaration,
+  toCSSProperties,
+  toCSSShorthand,
+  toCSSVar,
+  toPx,
+  toRem,
+  toTailwindClass,
+  toTailwindCorners,
+  uniformCorners
+});

package/dist/tokens.d.cts

@@ -0,0 +1,42 @@
+import { RadiusValue, RadiusLevel } from './index.cjs';
+export { BREAKPOINTS, Breakpoints, Corner, CornerRadii, RadiusScale, ResponsiveRadius, clampScale, createLinearScale, createScale, innerCorners, innerRadius, mobileRadius, nestingPair, parseCorners, parseRadius, requiredGap, responsiveRadius, roundCorners, scaleBy, setBottom, setCorner, setLeft, setRight, setTop, sortedBreakpoints, sortedLevels, stepRadius, toCSS, toCSSDeclaration, toCSSProperties, toCSSShorthand, toCSSVar, toPx, toRem, toTailwindClass, toTailwindCorners, uniformCorners } from './index.cjs';
+
+/**
+ * Resolve a token radius level to a `RadiusValue`.
+ *
+ * @example
+ * resolveRadius("md")   → { value: 8, unit: "px", original: "8px" }
+ * resolveRadius("full") → { value: 9999, unit: "px", original: "9999px" }
+ */
+declare function resolveRadius(level: RadiusLevel): RadiusValue;
+/**
+ * Resolve the full token radius scale.
+ */
+declare function resolveRadiusScale(): Record<RadiusLevel, RadiusValue>;
+/**
+ * Resolve the base `--radius` token (used by the `@theme` calc expressions).
+ *
+ * @example
+ * resolveBaseRadius() → { value: 8, unit: "px", original: "8px" }
+ */
+declare function resolveBaseRadius(): RadiusValue;
+/**
+ * Get the `@theme` calc-based aliases that Tailwind uses.
+ *
+ * These are the expressions from `css.ts` that derive from `--radius`:
+ * - `--radius-lg: var(--radius)`
+ * - `--radius-md: calc(var(--radius) - 2px)`
+ * - `--radius-sm: calc(var(--radius) - 4px)`
+ */
+declare function resolveThemeAliases(): Record<string, string>;
+/**
+ * Derive inner radius from a token level + gap.
+ *
+ * Convenience wrapper: resolves the token level, then computes inner radius.
+ *
+ * @example
+ * resolveInnerRadius("xl", 8) → { value: 4, unit: "px", original: "4px" }
+ */
+declare function resolveInnerRadius(level: RadiusLevel, gap: number): RadiusValue;
+
+export { RadiusLevel, RadiusValue, resolveBaseRadius, resolveInnerRadius, resolveRadius, resolveRadiusScale, resolveThemeAliases };

package/dist/tokens.d.ts

@@ -0,0 +1,42 @@
+import { RadiusValue, RadiusLevel } from './index.js';
+export { BREAKPOINTS, Breakpoints, Corner, CornerRadii, RadiusScale, ResponsiveRadius, clampScale, createLinearScale, createScale, innerCorners, innerRadius, mobileRadius, nestingPair, parseCorners, parseRadius, requiredGap, responsiveRadius, roundCorners, scaleBy, setBottom, setCorner, setLeft, setRight, setTop, sortedBreakpoints, sortedLevels, stepRadius, toCSS, toCSSDeclaration, toCSSProperties, toCSSShorthand, toCSSVar, toPx, toRem, toTailwindClass, toTailwindCorners, uniformCorners } from './index.js';
+
+/**
+ * Resolve a token radius level to a `RadiusValue`.
+ *
+ * @example
+ * resolveRadius("md")   → { value: 8, unit: "px", original: "8px" }
+ * resolveRadius("full") → { value: 9999, unit: "px", original: "9999px" }
+ */
+declare function resolveRadius(level: RadiusLevel): RadiusValue;
+/**
+ * Resolve the full token radius scale.
+ */
+declare function resolveRadiusScale(): Record<RadiusLevel, RadiusValue>;
+/**
+ * Resolve the base `--radius` token (used by the `@theme` calc expressions).
+ *
+ * @example
+ * resolveBaseRadius() → { value: 8, unit: "px", original: "8px" }
+ */
+declare function resolveBaseRadius(): RadiusValue;
+/**
+ * Get the `@theme` calc-based aliases that Tailwind uses.
+ *
+ * These are the expressions from `css.ts` that derive from `--radius`:
+ * - `--radius-lg: var(--radius)`
+ * - `--radius-md: calc(var(--radius) - 2px)`
+ * - `--radius-sm: calc(var(--radius) - 4px)`
+ */
+declare function resolveThemeAliases(): Record<string, string>;
+/**
+ * Derive inner radius from a token level + gap.
+ *
+ * Convenience wrapper: resolves the token level, then computes inner radius.
+ *
+ * @example
+ * resolveInnerRadius("xl", 8) → { value: 4, unit: "px", original: "4px" }
+ */
+declare function resolveInnerRadius(level: RadiusLevel, gap: number): RadiusValue;
+
+export { RadiusLevel, RadiusValue, resolveBaseRadius, resolveInnerRadius, resolveRadius, resolveRadiusScale, resolveThemeAliases };

package/dist/tokens.js

@@ -0,0 +1,122 @@
+import {
+  BREAKPOINTS,
+  clampScale,
+  createLinearScale,
+  createScale,
+  innerCorners,
+  innerRadius,
+  mobileRadius,
+  nestingPair,
+  parseCorners,
+  parseRadius,
+  requiredGap,
+  responsiveRadius,
+  roundCorners,
+  scaleBy,
+  setBottom,
+  setCorner,
+  setLeft,
+  setRight,
+  setTop,
+  sortedBreakpoints,
+  sortedLevels,
+  stepRadius,
+  toCSS,
+  toCSSDeclaration,
+  toCSSProperties,
+  toCSSShorthand,
+  toCSSVar,
+  toPx,
+  toRem,
+  toTailwindClass,
+  toTailwindCorners,
+  uniformCorners
+} from "./chunk-3Y6IG3UW.js";
+
+// src/resolve.ts
+import { light } from "@ariaui/tokens";
+var RADIUS_KEYS = {
+  none: "radius-none",
+  xxs: "radius-xxs",
+  xs: "radius-xs",
+  sm: "radius-sm",
+  md: "radius-md",
+  lg: "radius-lg",
+  xl: "radius-xl",
+  "2xl": "radius-2xl",
+  "3xl": "radius-3xl",
+  "4xl": "radius-4xl",
+  full: "radius-full"
+};
+function resolveRadius(level) {
+  const tokenKey = RADIUS_KEYS[level];
+  const tokenValue = light[tokenKey];
+  if (tokenValue === void 0) {
+    throw new Error(`Radius token not found: "${level}" (key: "${tokenKey}")`);
+  }
+  return parseRadius(tokenValue);
+}
+function resolveRadiusScale() {
+  const result = {};
+  for (const level of Object.keys(RADIUS_KEYS)) {
+    result[level] = resolveRadius(level);
+  }
+  return result;
+}
+function resolveBaseRadius() {
+  const value = light["radius"];
+  if (value === void 0) {
+    throw new Error('Base radius token "radius" not found');
+  }
+  return parseRadius(value);
+}
+function resolveThemeAliases() {
+  return {
+    lg: "var(--radius)",
+    md: "calc(var(--radius) - 2px)",
+    sm: "calc(var(--radius) - 4px)"
+  };
+}
+function resolveInnerRadius(level, gap) {
+  const outer = resolveRadius(level);
+  return innerRadius(outer, gap);
+}
+export {
+  BREAKPOINTS,
+  clampScale,
+  createLinearScale,
+  createScale,
+  innerCorners,
+  innerRadius,
+  mobileRadius,
+  nestingPair,
+  parseCorners,
+  parseRadius,
+  requiredGap,
+  resolveBaseRadius,
+  resolveInnerRadius,
+  resolveRadius,
+  resolveRadiusScale,
+  resolveThemeAliases,
+  responsiveRadius,
+  roundCorners,
+  scaleBy,
+  setBottom,
+  setCorner,
+  setLeft,
+  setRight,
+  setTop,
+  sortedBreakpoints,
+  sortedLevels,
+  stepRadius,
+  toCSS,
+  toCSSDeclaration,
+  toCSSProperties,
+  toCSSShorthand,
+  toCSSVar,
+  toPx,
+  toRem,
+  toTailwindClass,
+  toTailwindCorners,
+  uniformCorners
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@ariaui/radius",
+  "version": "0.1.1",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    },
+    "./tokens": {
+      "types": "./dist/tokens.d.ts",
+      "import": "./dist/tokens.js",
+      "require": "./dist/tokens.cjs",
+      "default": "./dist/tokens.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@ariaui/tokens": "0.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@ariaui/tokens": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@ariaui/tokens": "0.2.0"
+  },
+  "scripts": {
+    "build": "rimraf dist && tsup",
+    "dev": "rimraf dist && tsup --watch",
+    "lint": "eslint \"**/*.ts\"",
+    "clean": "rimraf node_modules && rimraf dist",
+    "test": "vitest run",
+    "test:watch": "vitest watch"
+  }
+}