@ariaui/radius 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -1,395 +0,0 @@
-"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);
-
-// index.ts
-var index_exports = {};
-__export(index_exports, {
-  BREAKPOINTS: () => BREAKPOINTS,
-  clampScale: () => clampScale,
-  createLinearScale: () => createLinearScale,
-  createScale: () => createScale,
-  innerCorners: () => innerCorners,
-  innerRadius: () => innerRadius,
-  mobileRadius: () => mobileRadius,
-  nestingPair: () => nestingPair,
-  parseCorners: () => parseCorners,
-  parseRadius: () => parseRadius,
-  requiredGap: () => requiredGap,
-  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(index_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})`;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  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
-});

package/dist/index.d.cts

@@ -1,305 +0,0 @@
-/**
- * A single radius value.
- *
- * The original unit is preserved; conversion to other units is on-demand
- * via the format module.
- */
-interface RadiusValue {
-    /** Numeric value in the original unit */
-    readonly value: number;
-    /** CSS unit */
-    readonly unit: "px" | "rem" | "%";
-    /** Original authored string, e.g. `"8px"`, `"0.5rem"` */
-    readonly original: string;
-}
-/**
- * Per-corner radii (CSS `border-radius` longhand).
- */
-interface CornerRadii {
-    readonly topLeft: RadiusValue;
-    readonly topRight: RadiusValue;
-    readonly bottomRight: RadiusValue;
-    readonly bottomLeft: RadiusValue;
-}
-/** Corner position names. */
-type Corner = "topLeft" | "topRight" | "bottomRight" | "bottomLeft";
-/**
- * Named radius scale levels matching `@ariaui/tokens`.
- */
-type RadiusLevel = "none" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "4xl" | "full";
-/** A radius scale: level name → value mapping. */
-type RadiusScale = Record<string, RadiusValue>;
-/** Breakpoint name → pixel value. */
-type Breakpoints = Record<string, number>;
-/** Responsive radius: default + optional breakpoint overrides. */
-interface ResponsiveRadius {
-    readonly default: RadiusValue;
-    readonly breakpoints: Record<string, RadiusValue>;
-}
-
-/**
- * Parse a single CSS radius value string into a `RadiusValue`.
- *
- * Accepts `px`, `rem`, and `%` units. Plain numbers are treated as `px`.
- *
- * @example
- * parseRadius("8px")    → { value: 8, unit: "px", original: "8px" }
- * parseRadius("0.5rem") → { value: 0.5, unit: "rem", original: "0.5rem" }
- * parseRadius(8)        → { value: 8, unit: "px", original: "8px" }
- */
-declare function parseRadius(input: string | number): RadiusValue;
-/**
- * Parse a CSS `border-radius` shorthand into per-corner `CornerRadii`.
- *
- * Follows CSS shorthand rules:
- * - 1 value: all corners
- * - 2 values: top-left/bottom-right, top-right/bottom-left
- * - 3 values: top-left, top-right/bottom-left, bottom-right
- * - 4 values: top-left, top-right, bottom-right, bottom-left
- *
- * Does **not** support the `x / y` elliptical radius syntax.
- *
- * @example
- * parseCorners("8px")                → all corners 8px
- * parseCorners("8px 4px")            → TL/BR=8, TR/BL=4
- * parseCorners("8px 4px 2px 0px")    → TL=8, TR=4, BR=2, BL=0
- */
-declare function parseCorners(input: string): CornerRadii;
-
-/**
- * Create a linear radius scale.
- *
- * Generates `count` steps starting from `base`, incrementing by `step`.
- * Steps are named `"0"`, `"1"`, `"2"`, etc.
- *
- * @example
- * createLinearScale(0, 4, 6)
- * // → { "0": 0px, "1": 4px, "2": 8px, "3": 12px, "4": 16px, "5": 20px }
- */
-declare function createLinearScale(base?: number, step?: number, count?: number): RadiusScale;
-/**
- * Create a radius scale from explicit named values.
- *
- * @example
- * createScale({ none: 0, sm: 4, md: 8, lg: 12, full: "9999px" })
- */
-declare function createScale(values: Record<string, number | string>): RadiusScale;
-/**
- * Scale all values in a radius scale by a factor.
- *
- * @example
- * scaleBy(scale, 1.5)  // 50% larger radii
- */
-declare function scaleBy(scale: RadiusScale, factor: number): RadiusScale;
-/**
- * Clamp all values in a scale to a [min, max] range.
- *
- * Values are clamped in their original unit.
- */
-declare function clampScale(scale: RadiusScale, min: number, max: number): RadiusScale;
-/**
- * Get level names sorted by value (ascending).
- */
-declare function sortedLevels(scale: RadiusScale): string[];
-/**
- * Step to the next or previous level in a scale.
- *
- * Levels are ordered by value. Returns the current level if at a boundary.
- */
-declare function stepRadius(scale: RadiusScale, current: string, direction: "up" | "down"): string;
-
-/**
- * Create uniform corners (all four corners the same).
- *
- * @example
- * uniformCorners("8px")
- * uniformCorners(8)
- * uniformCorners({ value: 8, unit: "px", original: "8px" })
- */
-declare function uniformCorners(radius: RadiusValue | string | number): CornerRadii;
-/**
- * Set a single corner, returning new CornerRadii.
- *
- * @example
- * setCorner(corners, "topLeft", "12px")
- */
-declare function setCorner(corners: CornerRadii, corner: Corner, value: RadiusValue | string | number): CornerRadii;
-/**
- * Set both top corners.
- */
-declare function setTop(corners: CornerRadii, value: RadiusValue | string | number): CornerRadii;
-/**
- * Set both bottom corners.
- */
-declare function setBottom(corners: CornerRadii, value: RadiusValue | string | number): CornerRadii;
-/**
- * Set both left corners.
- */
-declare function setLeft(corners: CornerRadii, value: RadiusValue | string | number): CornerRadii;
-/**
- * Set both right corners.
- */
-declare function setRight(corners: CornerRadii, value: RadiusValue | string | number): CornerRadii;
-/**
- * Round only the specified corners; all others are set to 0.
- *
- * @example
- * roundCorners("12px", "topLeft", "topRight")
- * // → TL=12px, TR=12px, BR=0px, BL=0px
- */
-declare function roundCorners(radius: RadiusValue | string | number, ...corners: Corner[]): CornerRadii;
-
-/**
- * Calculate the inner radius for a nested element.
- *
- * When a rounded parent has padding/gap, the child needs a smaller radius
- * to visually match the parent's curve: `inner = outer - gap`.
- *
- * Result is clamped to ≥ 0 (except for `9999px` pill shapes, where
- * the subtraction still yields a huge value = still pill).
- *
- * @param outer - Outer (parent) radius
- * @param gap   - Gap between parent and child edges (in the same unit as outer)
- *
- * @example
- * innerRadius("12px", 4)  → { value: 8, unit: "px", original: "8px" }
- * innerRadius("9999px", 8) → { value: 9991, unit: "px", original: "9991px" }
- * innerRadius("4px", 8)   → { value: 0, unit: "px", original: "0px" }
- */
-declare function innerRadius(outer: RadiusValue | string | number, gap: number): RadiusValue;
-/**
- * Calculate inner corners from outer corners and a uniform gap.
- *
- * Each corner's radius is reduced by `gap`, clamped to ≥ 0.
- *
- * @example
- * innerCorners(outerCorners, 8)
- */
-declare function innerCorners(outer: CornerRadii, gap: number): CornerRadii;
-/**
- * Calculate the gap needed to achieve a desired inner radius.
- *
- * `gap = outer.value - inner.value` (clamped to ≥ 0).
- */
-declare function requiredGap(outer: RadiusValue | string | number, inner: RadiusValue | string | number): number;
-/**
- * Suggest matching radii for a parent-child nesting pair.
- *
- * @param outerRadius - Desired outer radius in px
- * @param gap         - Padding/gap between parent and child
- *
- * @returns `{ outer, inner }` — both as `RadiusValue`
- *
- * @example
- * nestingPair(12, 8) → { outer: 12px, inner: 4px }
- * nestingPair(6, 8)  → { outer: 6px, inner: 0px }
- */
-declare function nestingPair(outerRadius: number, gap: number): {
-    outer: RadiusValue;
-    inner: RadiusValue;
-};
-
-/**
- * Default breakpoints matching Tailwind CSS v4 defaults.
- */
-declare const BREAKPOINTS: Breakpoints;
-/**
- * Create a responsive radius from a config map.
- *
- * The `"default"` key is required; other keys must match breakpoint names.
- *
- * @example
- * responsiveRadius({ default: "4px", md: "8px", lg: "12px" })
- * responsiveRadius({ default: 4, md: 8, lg: 12 })
- */
-declare function responsiveRadius(config: Record<string, string | number>, breakpoints?: Breakpoints): ResponsiveRadius;
-/**
- * Scale down a radius for mobile viewports.
- *
- * @param value  - Original radius
- * @param factor - Scale factor (default 0.75)
- *
- * @example
- * mobileRadius(parseRadius("12px"))         → { value: 9, ... }
- * mobileRadius(parseRadius("12px"), 0.5)    → { value: 6, ... }
- */
-declare function mobileRadius(value: RadiusValue, factor?: number): RadiusValue;
-/**
- * Get the sorted breakpoint entries from a `ResponsiveRadius`,
- * ordered by viewport width (ascending).
- */
-declare function sortedBreakpoints(responsive: ResponsiveRadius, breakpoints?: Breakpoints): Array<[string, number, RadiusValue]>;
-
-/**
- * Format a `RadiusValue` as a CSS value string in its original unit.
- *
- * @example
- * toCSS(parseRadius("8px"))    → "8px"
- * toCSS(parseRadius("0.5rem")) → "0.5rem"
- */
-declare function toCSS(value: RadiusValue): string;
-/**
- * Convert a `RadiusValue` to rem.
- *
- * @param base - Root font size in px (default 16)
- *
- * @example
- * toRem(parseRadius("8px"))        → "0.5rem"
- * toRem(parseRadius("0.5rem"))     → "0.5rem"
- * toRem(parseRadius("24px"), 16)   → "1.5rem"
- */
-declare function toRem(value: RadiusValue, base?: number): string;
-/**
- * Convert a `RadiusValue` to px.
- *
- * @param base - Root font size in px (default 16, used for rem → px)
- */
-declare function toPx(value: RadiusValue, base?: number): string;
-/**
- * Format `CornerRadii` as a CSS `border-radius` shorthand.
- *
- * Uses the most compact shorthand form possible.
- *
- * @example
- * toCSSShorthand(uniformCorners(8))     → "8px"
- * toCSSShorthand(corners)               → "8px 4px 2px 0px"
- */
-declare function toCSSShorthand(corners: CornerRadii): string;
-/**
- * Format `CornerRadii` as React `CSSProperties`.
- *
- * @example
- * toCSSProperties(corners)
- * // → { borderTopLeftRadius: "8px", borderTopRightRadius: "4px", ... }
- */
-declare function toCSSProperties(corners: CornerRadii): Record<string, string>;
-/**
- * Format `CornerRadii` as a CSS declaration block.
- *
- * Uses shorthand when possible.
- */
-declare function toCSSDeclaration(corners: CornerRadii): string;
-/**
- * Format a `RadiusValue` as a Tailwind CSS `rounded-[...]` class.
- *
- * @example
- * toTailwindClass(parseRadius("8px")) → "rounded-[8px]"
- */
-declare function toTailwindClass(value: RadiusValue): string;
-/**
- * Format `CornerRadii` as Tailwind per-corner classes.
- *
- * @example
- * toTailwindCorners(corners)
- * // → "rounded-tl-[8px] rounded-tr-[4px] rounded-br-[2px] rounded-bl-[0px]"
- */
-declare function toTailwindCorners(corners: CornerRadii): string;
-/**
- * Generate a CSS `var()` reference for a token radius level.
- *
- * @example
- * toCSSVar("md") → "var(--radius-md)"
- */
-declare function toCSSVar(level: string): string;
-
-export { BREAKPOINTS, type Breakpoints, type Corner, type CornerRadii, type RadiusLevel, type RadiusScale, type RadiusValue, type 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 };