@sigx/zero-daisyui 0.2.0-beta.4 → 0.2.0-beta.6

package/dist/lynx/manifest.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://signalxjs.github.io/zero/schemas/lynx-manifest.schema.json",
   "manifestVersion": 1,
-  "zeroVersion": "0.2.0-beta.4",
+  "zeroVersion": "0.2.0-beta.6",
   "name": "daisyui",
   "themes": [
     {
@@ -1803,6 +1803,6 @@
   "classGrammarVersion": 1,
   "capabilities": {
     "translated": 60,
-    "dropped": 227
+    "dropped": 324
   }
 }

package/dist/manifest.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://signalxjs.github.io/zero/schemas/ds-manifest.schema.json",
   "manifestVersion": 1,
-  "zeroVersion": "0.2.0-beta.4",
+  "zeroVersion": "0.2.0-beta.6",
   "name": "daisyui",
   "themes": [
     {

package/dist/recipes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recipes.d.ts","sourceRoot":"","sources":["../src/recipes.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"recipes.d.ts","sourceRoot":"","sources":["../src/recipes.ts"],"names":[],"mappings":"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"}

package/dist/recipes.js

@@ -436,18 +436,33 @@ export const tabs = {
     defaultVariants: { size: 'md', variant: 'border' },
     targets: {
         lynx: {
+            parts: {
+                // The default active ink — base-content, exactly what the
+                // shared `states.active.color` paints. One class, so any
+                // color-axis definition below (host + two classes, baked per
+                // theme) wins on specificity.
+                tab: { base: { '--tab-active-ink': 'var(--color-base-content)' } },
+            },
             variants: {
+                // `currentColor` never resolves on lynx (measured on device
+                // on both platforms, signalxjs/lynx#1079 — the underline was
+                // transparent everywhere), so the color axis restates its
+                // active ink as a plain custom property. `roleInk` reads
+                // theme colors through color-mix(), which the emitter bakes
+                // once per theme — the same per-color/per-theme literal the
+                // active `color:` rules already land as.
+                color: Object.fromEntries(ROLES.map((c) => [c, { tab: { base: { '--tab-active-ink': roleInk(c) } } }])),
                 variant: {
                     // The underline is a ::before on the web, which lynx
                     // drops — redrawn as a real bottom border on the tab
                     // itself (transparent at rest so activation never moves
-                    // the row). `currentColor` keeps it following the color
-                    // axis ink, the same mechanism switch's shared border
-                    // already relies on for lynx.
+                    // the row). The active ink rides `--tab-active-ink`
+                    // above — a plain var() chain, device-proven — instead
+                    // of `currentColor`, which lynx never resolves.
                     border: {
                         tab: {
                             base: { borderBottom: '3px solid transparent' },
-                            states: { active: { borderBottomColor: 'currentColor' } },
+                            states: { active: { borderBottomColor: 'var(--tab-active-ink)' } },
                         },
                     },
                     // `min()` does not exist on lynx (signalxjs/lynx#1066) and
@@ -862,6 +877,24 @@ const btnSizes = {
     lg: { trigger: { base: { height: fieldHeight('lg'), paddingInline: 'calc(var(--size-field) * 5)', fontSize: 'var(--text-md)' } } },
     xl: { trigger: { base: { height: fieldHeight('xl'), paddingInline: 'calc(var(--size-field) * 6)', fontSize: 'var(--text-lg)' } } },
 };
+/**
+ * `btn`'s inline padding restated physically, for the `targets.lynx`
+ * sections of every btn-wearing recipe: logical spellings resolve on iOS but
+ * not on Android (measured, signalxjs/lynx#1084), so the lynx emitter
+ * refuses `padding-inline`. Physical is that target's norm — lynx has no
+ * RTL flow for the logical spelling to flip with.
+ */
+const lynxBtnPad = (mult) => ({
+    paddingLeft: `calc(var(--size-field) * ${mult})`,
+    paddingRight: `calc(var(--size-field) * ${mult})`,
+});
+/** The btn size ramp's physical inline padding, for `targets.lynx.variants`. */
+const lynxBtnSizes = (part) => ({
+    xs: { [part]: { base: lynxBtnPad(2) } },
+    sm: { [part]: { base: lynxBtnPad(3) } },
+    lg: { [part]: { base: lynxBtnPad(5) } },
+    xl: { [part]: { base: lynxBtnPad(6) } },
+});
 export const dialog = {
     component: 'dialog',
     keyframes: {
@@ -942,6 +975,19 @@ export const dialog = {
     // Trigger-carried axes — see `btnColors` for why the popup is out of
     // reach and the trigger is the whole story here.
     variants: { color: btnColors(), size: btnSizes },
+    // The btn paddings and the footer's push-down, restated physically —
+    // see `lynxBtnPad` for the #1084 verdict this answers.
+    targets: {
+        lynx: {
+            parts: {
+                trigger: { base: lynxBtnPad(4) },
+                close: { base: lynxBtnPad(4) },
+                cancel: { base: lynxBtnPad(4) },
+                footer: { base: { marginTop: '1.5rem' } },
+            },
+            variants: { size: lynxBtnSizes('trigger') },
+        },
+    },
 };
 // daisy "dropdown-content"/card look for floating panels.
 const floatingPanel = {
@@ -982,6 +1028,16 @@ export const popover = {
     },
     // Trigger-carried axes — same wiring as dialog, same reason.
     variants: { color: btnColors(), size: btnSizes },
+    // The btn paddings, restated physically — see `lynxBtnPad` (#1084).
+    targets: {
+        lynx: {
+            parts: {
+                trigger: { base: lynxBtnPad(4) },
+                close: { base: lynxBtnPad(3) },
+            },
+            variants: { size: lynxBtnSizes('trigger') },
+        },
+    },
 };
 export const tooltip = {
     component: 'tooltip',
@@ -1017,6 +1073,13 @@ export const tooltip = {
     // Trigger-carried axes — same wiring as dialog, same reason. The bubble
     // stays daisy's neutral tooltip whatever the trigger's colour.
     variants: { color: btnColors(), size: btnSizes },
+    // The btn paddings, restated physically — see `lynxBtnPad` (#1084).
+    targets: {
+        lynx: {
+            parts: { trigger: { base: lynxBtnPad(4) } },
+            variants: { size: lynxBtnSizes('trigger') },
+        },
+    },
 };
 // daisy "menu in a dropdown" look.
 export const menu = {
@@ -1162,6 +1225,13 @@ export const menu = {
     // Trigger-carried axes — same wiring as dialog, same reason. The dropdown
     // and its items are top-layer siblings the donut cannot reach.
     variants: { color: btnColors(), size: btnSizes },
+    // The btn paddings, restated physically — see `lynxBtnPad` (#1084).
+    targets: {
+        lynx: {
+            parts: { trigger: { base: lynxBtnPad(4) } },
+            variants: { size: lynxBtnSizes('trigger') },
+        },
+    },
 };
 export const field = {
     component: 'field',
@@ -1427,6 +1497,45 @@ export const checkbox = {
     // control and its text. Declared rather than left implicit so the
     // delegation reads as a decision.
     skipStates: { root: ['focus-visible'] },
+    // `currentColor` never resolves on lynx (measured on device on both
+    // platforms, signalxjs/lynx#1079), so the tick shipped invisible and the
+    // ring's color-mix-over-currentColor fallback dropped the whole border.
+    // Both restated with the named accents the web spellings resolve to —
+    // plain var() chains, the switch's device-proven #380 mechanism.
+    targets: {
+        lynx: {
+            parts: {
+                control: {
+                    // The web fallback (`color-mix(in oklab, … currentColor …)`)
+                    // exists for consumers that unset the accent; this package
+                    // always defines it, so the plain accent IS the ring.
+                    base: { border: 'var(--border) solid var(--checkbox-accent)' },
+                },
+                indicator: {
+                    // The tick's fill: the control's `color:` names
+                    // `--checkbox-on-accent`, and `currentColor` was that
+                    // ink by inheritance — spend it directly.
+                    //
+                    // The tick's motion, restated as `transform`: the
+                    // standalone `rotate`/`translate` properties resolve on
+                    // iOS but not on Android (measured, signalxjs/lynx#1084),
+                    // so the emitter refuses them. `transform` functions are
+                    // proven on both platforms — and the transition follows
+                    // the property that now moves.
+                    base: {
+                        backgroundColor: 'var(--checkbox-on-accent)',
+                        transform: 'rotate(45deg)',
+                        transition: 'clip-path var(--duration-slow) var(--ease-standard) var(--duration-instant), '
+                            + 'opacity var(--duration-instant) var(--ease-standard) var(--duration-instant), '
+                            + 'transform var(--duration-slow) var(--ease-standard) var(--duration-instant)',
+                    },
+                    // The order matches the standalone properties' fixed
+                    // apply order (translate, then rotate).
+                    states: { indeterminate: { transform: 'translateY(-35%) rotate(0deg)' } },
+                },
+            },
+        },
+    },
 };
 // --------------------------------------------------------------------------
 // 3. radioGroup — replace the whole export
@@ -1542,6 +1651,25 @@ export const radioGroup = {
     // wraps it. Declared rather than left implicit so the delegation reads
     // as a decision.
     skipStates: { item: ['focus-visible'] },
+    // `currentColor` never resolves on lynx (measured on device on both
+    // platforms, signalxjs/lynx#1079), so the checked ring and dot shipped
+    // invisible, and the unchecked ring's color-mix-over-currentColor
+    // fallback dropped the whole border. All three restated with the accent
+    // the control's own `color:` names — plain var() chains, the switch's
+    // device-proven #380 mechanism.
+    targets: {
+        lynx: {
+            parts: {
+                'item-control': {
+                    base: { border: 'var(--border) solid var(--radio-accent)' },
+                    states: { checked: { borderColor: 'var(--radio-accent)' } },
+                },
+                'item-indicator': {
+                    states: { checked: { backgroundColor: 'var(--radio-accent)' } },
+                },
+            },
+        },
+    },
 };
 // --------------------------------------------------------------------------
 // 4. progress — replace the whole export (only the two radius lines move)
@@ -1649,6 +1777,18 @@ export const progress = {
         // other way.
         'zero-daisy-indeterminate': 'from { margin-inline-start: -40%; } to { margin-inline-start: 100%; }',
     },
+    // The same sweep with a physical margin: logical spellings resolve on
+    // iOS but not on Android (measured, signalxjs/lynx#1084), so the emitter
+    // refuses the shared keyframes. Physical is the lynx target's norm — no
+    // RTL flow there for the sweep to mirror with. Keyframes merge per name,
+    // so this REPLACES the shared animation on lynx.
+    targets: {
+        lynx: {
+            keyframes: {
+                'zero-daisy-indeterminate': 'from { margin-left: -40%; } to { margin-left: 100%; }',
+            },
+        },
+    },
 };
 export const slider = {
     component: 'slider',
@@ -1773,6 +1913,22 @@ export const slider = {
     targets: {
         lynx: {
             parts: {
+                track: {
+                    // The web track's `margin-block` breathing room,
+                    // restated physically: logical spellings resolve on iOS
+                    // but not on Android (measured, signalxjs/lynx#1084), so
+                    // the emitter refuses them. Physical is the lynx
+                    // target's norm — no RTL flow there.
+                    base: {
+                        marginTop: 'calc(var(--size-selector) * 1.5)',
+                        marginBottom: 'calc(var(--size-selector) * 1.5)',
+                    },
+                },
+                mark: {
+                    // Same #1084 verdict: the tick labels hang below the
+                    // track off a physical padding.
+                    base: { paddingTop: 'calc(var(--size-selector) * 2 + var(--space-2xs))' },
+                },
                 range: {
                     // The web fill deepens the accent 90/10 toward
                     // base-content (`progressFill`'s recipe); the plain
@@ -1796,9 +1952,20 @@ export const slider = {
                     // thumb — a native-input trick with no lynx equivalent;
                     // the composed `.zx-slider__range` box above IS that
                     // fill here, so the knob only needs its own two paints.
+                    //
+                    // The centering geometry is restated physically beside
+                    // the paint: `inset-block-start`/`translate`/
+                    // `margin-inline-start` resolve on iOS but not on
+                    // Android (measured, signalxjs/lynx#1084 — the knob sat
+                    // off-center there), so the emitter refuses them.
+                    // `top` + `transform: translateY()` + `margin-left` are
+                    // proven on both platforms.
                     base: {
                         background: 'var(--color-base-100)',
                         border: '0.25rem solid var(--slider-accent)',
+                        top: '50%',
+                        transform: 'translateY(-50%)',
+                        marginLeft: 'calc(var(--size-selector) * -2.5)',
                     },
                 },
             },
@@ -2016,6 +2183,17 @@ export const select = {
     // Base equals the default (`tokens:` accent, `fieldControl`'s md height),
     // so the twins restate it; declared for the manifest (signalxjs/lynx#1070).
     defaultVariants: { color: 'primary', size: 'md' },
+    // The btn paddings, restated physically — see `lynxBtnPad` (#1084).
+    // The trigger ramp restates `md` too (unlike `btnSizes`), so its lynx
+    // counterpart does as well.
+    targets: {
+        lynx: {
+            parts: { trigger: { base: lynxBtnPad(4) } },
+            variants: {
+                size: { ...lynxBtnSizes('trigger'), md: { trigger: { base: lynxBtnPad(4) } } },
+            },
+        },
+    },
 };
 /**
  * daisy's BUTTON ramp — `.btn`'s fixed height per size step, in `--size-field`
@@ -2239,6 +2417,17 @@ export const button = {
     },
     defaultVariants: { color: 'primary', variant: 'solid', size: 'md' },
     keyframes: { 'zero-daisyui-btn-spin': 'to { transform: rotate(360deg) }' },
+    // The icon chips' zeroed inline padding, restated physically: logical
+    // spellings resolve on iOS but not on Android (measured,
+    // signalxjs/lynx#1084), so the emitter refuses them.
+    targets: {
+        lynx: {
+            modifiers: {
+                square: { root: { base: { paddingLeft: '0', paddingRight: '0' } } },
+                circle: { root: { base: { paddingLeft: '0', paddingRight: '0' } } },
+            },
+        },
+    },
 };
 export const avatar = {
     component: 'avatar',
@@ -2464,6 +2653,24 @@ export const toast = {
     // signalxjs/lynx#1070. No `color` default: the un-attributed toast is a
     // neutral base-200 surface, outside the color vocabulary.
     defaultVariants: { size: 'md' },
+    // The corner placements' physical anchors: logical inset spellings
+    // resolve on iOS but not on Android (measured, signalxjs/lynx#1084), so
+    // the emitter refuses them. Physical is the lynx target's norm — no RTL
+    // flow there, so `start` IS left and `end` IS right.
+    targets: {
+        lynx: {
+            parts: {
+                viewport: {
+                    selectors: {
+                        '&[data-placement="top-start"]': { left: '0' },
+                        '&[data-placement="top-end"]': { right: '0' },
+                        '&[data-placement="bottom-start"]': { left: '0' },
+                        '&[data-placement="bottom-end"]': { right: '0' },
+                    },
+                },
+            },
+        },
+    },
 };
 export const combobox = {
     component: 'combobox',
@@ -2938,6 +3145,17 @@ export const numberInput = {
             xl: { control: { base: { height: fieldHeight('xl') } }, input: { base: { fontSize: 'var(--text-lg)', padding: 'var(--space-lg) var(--space-xl)' } } },
         },
     },
+    // The steppers' inline padding, restated physically: logical spellings
+    // resolve on iOS but not on Android (measured, signalxjs/lynx#1084), so
+    // the emitter refuses them.
+    targets: {
+        lynx: {
+            parts: {
+                'increment-trigger': { base: { paddingLeft: 'var(--space-lg)', paddingRight: 'var(--space-lg)' } },
+                'decrement-trigger': { base: { paddingLeft: 'var(--space-lg)', paddingRight: 'var(--space-lg)' } },
+            },
+        },
+    },
 };
 /**
  * daisy "rating" flavor: a row of orange filled symbols. The default content
@@ -3227,6 +3445,16 @@ export const treeView = {
             xl: { root: { base: { '--tree-text': 'var(--text-lg)' } } },
         },
     },
+    // The indent, restated physically: logical spellings resolve on iOS but
+    // not on Android (measured, signalxjs/lynx#1084), so the emitter refuses
+    // them. Physical is the lynx target's norm — no RTL flow there.
+    targets: {
+        lynx: {
+            parts: {
+                'branch-content': { base: { paddingLeft: 'var(--space-lg)' } },
+            },
+        },
+    },
 };
 /**
  * daisy "input" flavor: the shared field box with nothing in it but the text.
@@ -3446,6 +3674,26 @@ export const nativeSelect = {
             xl: { control: { base: { height: fieldHeight('xl'), fontSize: 'var(--text-lg)', padding: 'var(--space-lg) var(--space-xl)', paddingInlineEnd: 'calc(var(--space-xl) + 1.25em)' } } },
         },
     },
+    // The chevron gutter and the indicator anchor, restated physically:
+    // logical spellings resolve on iOS but not on Android (measured,
+    // signalxjs/lynx#1084), so the emitter refuses them. Physical is the
+    // lynx target's norm — no RTL flow there, so `end` IS right.
+    targets: {
+        lynx: {
+            parts: {
+                control: { base: { paddingRight: 'calc(var(--space-md) + 1.25em)' } },
+                indicator: { base: { right: 'var(--space-md)' } },
+            },
+            variants: {
+                size: {
+                    xs: { control: { base: { paddingRight: 'calc(var(--space-xs) + 1.25em)' } } },
+                    sm: { control: { base: { paddingRight: 'calc(var(--space-sm) + 1.25em)' } } },
+                    lg: { control: { base: { paddingRight: 'calc(var(--space-lg) + 1.25em)' } } },
+                    xl: { control: { base: { paddingRight: 'calc(var(--space-xl) + 1.25em)' } } },
+                },
+            },
+        },
+    },
 };
 // ── Content tier (#311) ───────────────────────────────────────────────────
 /**
@@ -3910,6 +4158,30 @@ export const indicator = {
             xl: { item: { base: { fontSize: 'var(--text-lg)' } } },
         },
     },
+    // The corner slots, restated physically: logical inset spellings and the
+    // standalone `translate` property resolve on iOS but not on Android
+    // (measured, signalxjs/lynx#1084), so the emitter refuses them. Physical
+    // anchors plus `transform: translate()` are proven on both platforms,
+    // and physical is the lynx target's norm — no RTL flow there, so the
+    // hand-flipped RTL rules above have nothing to engage with either.
+    targets: {
+        lynx: {
+            parts: {
+                item: {
+                    selectors: {
+                        '&[data-placement="top-start"]': { top: '0', left: '0', transform: 'translate(-50%, -50%)' },
+                        '&[data-placement="top"]': { top: '0', left: '50%', transform: 'translate(-50%, -50%)' },
+                        '&[data-placement="top-end"]': { top: '0', right: '0', transform: 'translate(50%, -50%)' },
+                        '&[data-placement="start"]': { top: '50%', left: '0', transform: 'translate(-50%, -50%)' },
+                        '&[data-placement="end"]': { top: '50%', right: '0', transform: 'translate(50%, -50%)' },
+                        '&[data-placement="bottom-start"]': { bottom: '0', left: '0', transform: 'translate(-50%, 50%)' },
+                        '&[data-placement="bottom"]': { bottom: '0', left: '50%', transform: 'translate(-50%, 50%)' },
+                        '&[data-placement="bottom-end"]': { bottom: '0', right: '0', transform: 'translate(50%, 50%)' },
+                    },
+                },
+            },
+        },
+    },
 };
 /** daisy stats: the rounded base-100 panel with rule-thin item joins. */
 export const stats = {
@@ -4227,6 +4499,16 @@ export const chat = {
             xl: { bubble: { base: { fontSize: 'var(--text-lg)', padding: 'var(--space-md) var(--space-xl)' } } },
         },
     },
+    // The row's vertical padding, restated physically: logical spellings
+    // resolve on iOS but not on Android (measured, signalxjs/lynx#1084), so
+    // the emitter refuses them.
+    targets: {
+        lynx: {
+            parts: {
+                root: { base: { paddingTop: 'var(--space-2xs)', paddingBottom: 'var(--space-2xs)' } },
+            },
+        },
+    },
 };
 /** daisy radial-progress: --value became --progress-percent; same ring. */
 export const radialProgress = {
@@ -4678,6 +4960,16 @@ export const pagination = {
             xl: { root: { base: { '--pg-size': 'calc(var(--size-field) * 14)', '--pg-font': 'var(--text-lg)' } } },
         },
     },
+    // The cell's inline padding, restated physically: logical spellings
+    // resolve on iOS but not on Android (measured, signalxjs/lynx#1084), so
+    // the emitter refuses them.
+    targets: {
+        lynx: {
+            parts: {
+                item: { base: { paddingLeft: 'var(--space-2xs)', paddingRight: 'var(--space-2xs)' } },
+            },
+        },
+    },
 };
 /**
  * Steps — daisy's steps translated to the richer rail: bold numbered discs
@@ -4824,6 +5116,34 @@ export const steps = {
             xl: { root: { base: { '--steps-ind': 'calc(var(--size-selector) * 9)', '--steps-font': 'var(--text-md)' } } },
         },
     },
+    // The bridge's anchors and the vertical item's tail padding, restated
+    // physically: logical spellings resolve on iOS but not on Android
+    // (measured, signalxjs/lynx#1084), so the emitter refuses them. Physical
+    // is the lynx target's norm — no RTL flow there to mirror with.
+    targets: {
+        lynx: {
+            parts: {
+                item: {
+                    selectors: {
+                        '&[data-orientation="vertical"]': { paddingBottom: 'var(--space-lg)' },
+                    },
+                },
+                separator: {
+                    selectors: {
+                        '&[data-orientation="horizontal"]': {
+                            top: 'calc(var(--space-xs) + var(--steps-ind) / 2)',
+                            left: '50%',
+                        },
+                        '&[data-orientation="vertical"]': {
+                            left: 'calc(var(--space-xs) + (var(--steps-ind) - var(--border)) / 2)',
+                            top: 'calc(var(--space-xs) + var(--steps-ind))',
+                            bottom: 'calc(var(--space-xs) * -1)',
+                        },
+                    },
+                },
+            },
+        },
+    },
 };
 /**
  * Drawer — daisy's drawer-side as a native <dialog> edge sheet: base-100
@@ -4896,6 +5216,16 @@ export const drawer = {
     // Trigger-carried axes — see `btnColors` for why the panel is out of
     // reach and the trigger is the whole story here.
     variants: { color: btnColors(), size: btnSizes },
+    // The btn paddings, restated physically — see `lynxBtnPad` (#1084).
+    targets: {
+        lynx: {
+            parts: {
+                trigger: { base: lynxBtnPad(4) },
+                close: { base: lynxBtnPad(4) },
+            },
+            variants: { size: lynxBtnSizes('trigger') },
+        },
+    },
 };
 /**
  * Table — daisy's `table`: quiet base-200 row rules in a rounded box,
@@ -5283,6 +5613,22 @@ export const carousel = {
             xl: { root: { base: { '--carousel-dot': '0.875rem', '--carousel-nav': '3rem' } } },
         },
     },
+    // The nav buttons' anchors, restated physically: logical inset
+    // spellings resolve on iOS but not on Android (measured,
+    // signalxjs/lynx#1084), so the emitter refuses them. Physical is the
+    // lynx target's norm — no RTL flow there, so `start` IS left.
+    targets: {
+        lynx: {
+            parts: {
+                'prev-trigger': {
+                    base: { top: 'calc(50% - var(--carousel-nav) / 2)', left: 'var(--space-sm)' },
+                },
+                'next-trigger': {
+                    base: { top: 'calc(50% - var(--carousel-nav) / 2)', right: 'var(--space-sm)' },
+                },
+            },
+        },
+    },
 };
 /**
  * Swap — daisy's signature swap-rotate as the ONE look: the leaving face
@@ -5524,6 +5870,21 @@ export const diff = {
                 },
             },
         },
+        // The reveal pane's pin and the handle's centering margin, restated
+        // physically: logical spellings resolve on iOS but not on Android
+        // (measured, signalxjs/lynx#1084), so the emitter refuses them.
+        // Physical is the lynx target's norm — no RTL flow there to mirror
+        // with.
+        lynx: {
+            parts: {
+                after: {
+                    base: { top: '0', bottom: '0', left: '0' },
+                },
+                handle: {
+                    base: { top: '0', bottom: '0', marginLeft: 'calc(var(--diff-hit) / -2)' },
+                },
+            },
+        },
     },
 };
 export const recipes = [