@mekari/pixel3-styled-system 0.1.6 → 0.1.7

package/recipes/tag-slot-recipe.mjs

@@ -66,6 +66,7 @@ export const tagSlotRecipe = /* @__PURE__ */ Object.assign(tagSlotRecipeFn, {
   __recipe__: false,
   __name__: 'tagSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: tagSlotRecipeVariantKeys,
   variantMap: {
   "size": [

package/recipes/text-recipe.d.ts

@@ -17,11 +17,14 @@ type TextRecipeVariantMap = {
   [key in keyof TextRecipeVariant]: Array<TextRecipeVariant[key]>
 }
 
+
+
 export type TextRecipeVariantProps = {
   [key in keyof TextRecipeVariant]?: ConditionalValue<TextRecipeVariant[key]> | undefined
 }
 
 export interface TextRecipeRecipe {
+  
   __type: TextRecipeVariantProps
   (props?: TextRecipeVariantProps): string
   raw: (props?: TextRecipeVariantProps) => TextRecipeVariantProps

package/recipes/textarea-recipe.d.ts

@@ -10,11 +10,14 @@ type TextareaRecipeVariantMap = {
   [key in keyof TextareaRecipeVariant]: Array<TextareaRecipeVariant[key]>
 }
 
+
+
 export type TextareaRecipeVariantProps = {
   [key in keyof TextareaRecipeVariant]?: ConditionalValue<TextareaRecipeVariant[key]> | undefined
 }
 
 export interface TextareaRecipeRecipe {
+  
   __type: TextareaRecipeVariantProps
   (props?: TextareaRecipeVariantProps): string
   raw: (props?: TextareaRecipeVariantProps) => TextareaRecipeVariantProps

package/recipes/textlink-recipe.d.ts

@@ -13,11 +13,14 @@ type TextlinkRecipeVariantMap = {
   [key in keyof TextlinkRecipeVariant]: Array<TextlinkRecipeVariant[key]>
 }
 
+
+
 export type TextlinkRecipeVariantProps = {
   [key in keyof TextlinkRecipeVariant]?: TextlinkRecipeVariant[key] | undefined
 }
 
 export interface TextlinkRecipeRecipe {
+  
   __type: TextlinkRecipeVariantProps
   (props?: TextlinkRecipeVariantProps): string
   raw: (props?: TextlinkRecipeVariantProps) => TextlinkRecipeVariantProps

package/recipes/time-item-recipe.d.ts

@@ -10,11 +10,14 @@ type TimeItemRecipeVariantMap = {
   [key in keyof TimeItemRecipeVariant]: Array<TimeItemRecipeVariant[key]>
 }
 
+
+
 export type TimeItemRecipeVariantProps = {
   [key in keyof TimeItemRecipeVariant]?: ConditionalValue<TimeItemRecipeVariant[key]> | undefined
 }
 
 export interface TimeItemRecipeRecipe {
+  
   __type: TimeItemRecipeVariantProps
   (props?: TimeItemRecipeVariantProps): string
   raw: (props?: TimeItemRecipeVariantProps) => TimeItemRecipeVariantProps

package/recipes/time-panel-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type TimePanelSlotRecipeVariantMap = {
   [key in keyof TimePanelSlotRecipeVariant]: Array<TimePanelSlotRecipeVariant[key]>
 }
 
+type TimePanelSlotRecipeSlot = "root" | "column"
+
 export type TimePanelSlotRecipeVariantProps = {
   [key in keyof TimePanelSlotRecipeVariant]?: ConditionalValue<TimePanelSlotRecipeVariant[key]> | undefined
 }
 
 export interface TimePanelSlotRecipeRecipe {
+  __slot: TimePanelSlotRecipeSlot
   __type: TimePanelSlotRecipeVariantProps
-  (props?: TimePanelSlotRecipeVariantProps): Pretty<Record<"root" | "column", string>>
+  (props?: TimePanelSlotRecipeVariantProps): Pretty<Record<TimePanelSlotRecipeSlot, string>>
   raw: (props?: TimePanelSlotRecipeVariantProps) => TimePanelSlotRecipeVariantProps
   variantMap: TimePanelSlotRecipeVariantMap
   variantKeys: Array<keyof TimePanelSlotRecipeVariant>

package/recipes/time-panel-slot-recipe.mjs

@@ -27,6 +27,7 @@ export const timePanelSlotRecipe = /* @__PURE__ */ Object.assign(timePanelSlotRe
   __recipe__: false,
   __name__: 'timePanelSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: timePanelSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

package/recipes/timeline-accordion-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type TimelineAccordionSlotRecipeVariantMap = {
   [key in keyof TimelineAccordionSlotRecipeVariant]: Array<TimelineAccordionSlotRecipeVariant[key]>
 }
 
+type TimelineAccordionSlotRecipeSlot = "body" | "separator" | "icon" | "topConnector" | "bottomConnector" | "title" | "label"
+
 export type TimelineAccordionSlotRecipeVariantProps = {
   [key in keyof TimelineAccordionSlotRecipeVariant]?: ConditionalValue<TimelineAccordionSlotRecipeVariant[key]> | undefined
 }
 
 export interface TimelineAccordionSlotRecipeRecipe {
+  __slot: TimelineAccordionSlotRecipeSlot
   __type: TimelineAccordionSlotRecipeVariantProps
-  (props?: TimelineAccordionSlotRecipeVariantProps): Pretty<Record<"body" | "separator" | "icon" | "topConnector" | "bottomConnector" | "title" | "label", string>>
+  (props?: TimelineAccordionSlotRecipeVariantProps): Pretty<Record<TimelineAccordionSlotRecipeSlot, string>>
   raw: (props?: TimelineAccordionSlotRecipeVariantProps) => TimelineAccordionSlotRecipeVariantProps
   variantMap: TimelineAccordionSlotRecipeVariantMap
   variantKeys: Array<keyof TimelineAccordionSlotRecipeVariant>

package/recipes/timeline-accordion-slot-recipe.mjs

@@ -47,6 +47,7 @@ export const timelineAccordionSlotRecipe = /* @__PURE__ */ Object.assign(timelin
   __recipe__: false,
   __name__: 'timelineAccordionSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: timelineAccordionSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

package/recipes/timeline-document-slot-recipe.d.ts

@@ -13,13 +13,16 @@ type TimelineDocumentSlotRecipeVariantMap = {
   [key in keyof TimelineDocumentSlotRecipeVariant]: Array<TimelineDocumentSlotRecipeVariant[key]>
 }
 
+type TimelineDocumentSlotRecipeSlot = "root" | "content" | "title" | "description" | "fileSize"
+
 export type TimelineDocumentSlotRecipeVariantProps = {
   [key in keyof TimelineDocumentSlotRecipeVariant]?: ConditionalValue<TimelineDocumentSlotRecipeVariant[key]> | undefined
 }
 
 export interface TimelineDocumentSlotRecipeRecipe {
+  __slot: TimelineDocumentSlotRecipeSlot
   __type: TimelineDocumentSlotRecipeVariantProps
-  (props?: TimelineDocumentSlotRecipeVariantProps): Pretty<Record<"root" | "content" | "title" | "description" | "fileSize", string>>
+  (props?: TimelineDocumentSlotRecipeVariantProps): Pretty<Record<TimelineDocumentSlotRecipeSlot, string>>
   raw: (props?: TimelineDocumentSlotRecipeVariantProps) => TimelineDocumentSlotRecipeVariantProps
   variantMap: TimelineDocumentSlotRecipeVariantMap
   variantKeys: Array<keyof TimelineDocumentSlotRecipeVariant>

package/recipes/timeline-document-slot-recipe.mjs

@@ -43,6 +43,7 @@ export const timelineDocumentSlotRecipe = /* @__PURE__ */ Object.assign(timeline
   __recipe__: false,
   __name__: 'timelineDocumentSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: timelineDocumentSlotRecipeVariantKeys,
   variantMap: {
   "icon": [

package/recipes/timeline-log-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type TimelineLogSlotRecipeVariantMap = {
   [key in keyof TimelineLogSlotRecipeVariant]: Array<TimelineLogSlotRecipeVariant[key]>
 }
 
+type TimelineLogSlotRecipeSlot = "root" | "log" | "logText" | "logIcon" | "content" | "logItem"
+
 export type TimelineLogSlotRecipeVariantProps = {
   [key in keyof TimelineLogSlotRecipeVariant]?: ConditionalValue<TimelineLogSlotRecipeVariant[key]> | undefined
 }
 
 export interface TimelineLogSlotRecipeRecipe {
+  __slot: TimelineLogSlotRecipeSlot
   __type: TimelineLogSlotRecipeVariantProps
-  (props?: TimelineLogSlotRecipeVariantProps): Pretty<Record<"root" | "log" | "logText" | "logIcon" | "content" | "logItem", string>>
+  (props?: TimelineLogSlotRecipeVariantProps): Pretty<Record<TimelineLogSlotRecipeSlot, string>>
   raw: (props?: TimelineLogSlotRecipeVariantProps) => TimelineLogSlotRecipeVariantProps
   variantMap: TimelineLogSlotRecipeVariantMap
   variantKeys: Array<keyof TimelineLogSlotRecipeVariant>

package/recipes/timeline-log-slot-recipe.mjs

@@ -43,6 +43,7 @@ export const timelineLogSlotRecipe = /* @__PURE__ */ Object.assign(timelineLogSl
   __recipe__: false,
   __name__: 'timelineLogSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: timelineLogSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

package/recipes/timeline-separator-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type TimelineSeparatorSlotRecipeVariantMap = {
   [key in keyof TimelineSeparatorSlotRecipeVariant]: Array<TimelineSeparatorSlotRecipeVariant[key]>
 }
 
+type TimelineSeparatorSlotRecipeSlot = "root" | "topConnector" | "bottomConnector"
+
 export type TimelineSeparatorSlotRecipeVariantProps = {
   [key in keyof TimelineSeparatorSlotRecipeVariant]?: ConditionalValue<TimelineSeparatorSlotRecipeVariant[key]> | undefined
 }
 
 export interface TimelineSeparatorSlotRecipeRecipe {
+  __slot: TimelineSeparatorSlotRecipeSlot
   __type: TimelineSeparatorSlotRecipeVariantProps
-  (props?: TimelineSeparatorSlotRecipeVariantProps): Pretty<Record<"root" | "topConnector" | "bottomConnector", string>>
+  (props?: TimelineSeparatorSlotRecipeVariantProps): Pretty<Record<TimelineSeparatorSlotRecipeSlot, string>>
   raw: (props?: TimelineSeparatorSlotRecipeVariantProps) => TimelineSeparatorSlotRecipeVariantProps
   variantMap: TimelineSeparatorSlotRecipeVariantMap
   variantKeys: Array<keyof TimelineSeparatorSlotRecipeVariant>

package/recipes/timeline-separator-slot-recipe.mjs

@@ -31,6 +31,7 @@ export const timelineSeparatorSlotRecipe = /* @__PURE__ */ Object.assign(timelin
   __recipe__: false,
   __name__: 'timelineSeparatorSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: timelineSeparatorSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

package/recipes/timeline-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type TimelineSlotRecipeVariantMap = {
   [key in keyof TimelineSlotRecipeVariant]: Array<TimelineSlotRecipeVariant[key]>
 }
 
+type TimelineSlotRecipeSlot = "root" | "body" | "caption" | "content" | "item"
+
 export type TimelineSlotRecipeVariantProps = {
   [key in keyof TimelineSlotRecipeVariant]?: ConditionalValue<TimelineSlotRecipeVariant[key]> | undefined
 }
 
 export interface TimelineSlotRecipeRecipe {
+  __slot: TimelineSlotRecipeSlot
   __type: TimelineSlotRecipeVariantProps
-  (props?: TimelineSlotRecipeVariantProps): Pretty<Record<"root" | "body" | "caption" | "content" | "item", string>>
+  (props?: TimelineSlotRecipeVariantProps): Pretty<Record<TimelineSlotRecipeSlot, string>>
   raw: (props?: TimelineSlotRecipeVariantProps) => TimelineSlotRecipeVariantProps
   variantMap: TimelineSlotRecipeVariantMap
   variantKeys: Array<keyof TimelineSlotRecipeVariant>

package/recipes/timeline-slot-recipe.mjs

@@ -39,6 +39,7 @@ export const timelineSlotRecipe = /* @__PURE__ */ Object.assign(timelineSlotReci
   __recipe__: false,
   __name__: 'timelineSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: timelineSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

package/recipes/toast-slot-recipe.d.ts

@@ -13,13 +13,16 @@ type ToastSlotRecipeVariantMap = {
   [key in keyof ToastSlotRecipeVariant]: Array<ToastSlotRecipeVariant[key]>
 }
 
+type ToastSlotRecipeSlot = "root" | "icon" | "label"
+
 export type ToastSlotRecipeVariantProps = {
   [key in keyof ToastSlotRecipeVariant]?: ToastSlotRecipeVariant[key] | undefined
 }
 
 export interface ToastSlotRecipeRecipe {
+  __slot: ToastSlotRecipeSlot
   __type: ToastSlotRecipeVariantProps
-  (props?: ToastSlotRecipeVariantProps): Pretty<Record<"root" | "icon" | "label", string>>
+  (props?: ToastSlotRecipeVariantProps): Pretty<Record<ToastSlotRecipeSlot, string>>
   raw: (props?: ToastSlotRecipeVariantProps) => ToastSlotRecipeVariantProps
   variantMap: ToastSlotRecipeVariantMap
   variantKeys: Array<keyof ToastSlotRecipeVariant>

package/recipes/toast-slot-recipe.mjs

@@ -77,6 +77,7 @@ export const toastSlotRecipe = /* @__PURE__ */ Object.assign(toastSlotRecipeFn,
   __recipe__: false,
   __name__: 'toastSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: toastSlotRecipeVariantKeys,
   variantMap: {
   "variant": [

package/recipes/toggle-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type ToggleSlotRecipeVariantMap = {
   [key in keyof ToggleSlotRecipeVariant]: Array<ToggleSlotRecipeVariant[key]>
 }
 
+type ToggleSlotRecipeSlot = "root" | "control" | "label"
+
 export type ToggleSlotRecipeVariantProps = {
   [key in keyof ToggleSlotRecipeVariant]?: ConditionalValue<ToggleSlotRecipeVariant[key]> | undefined
 }
 
 export interface ToggleSlotRecipeRecipe {
+  __slot: ToggleSlotRecipeSlot
   __type: ToggleSlotRecipeVariantProps
-  (props?: ToggleSlotRecipeVariantProps): Pretty<Record<"root" | "control" | "label", string>>
+  (props?: ToggleSlotRecipeVariantProps): Pretty<Record<ToggleSlotRecipeSlot, string>>
   raw: (props?: ToggleSlotRecipeVariantProps) => ToggleSlotRecipeVariantProps
   variantMap: ToggleSlotRecipeVariantMap
   variantKeys: Array<keyof ToggleSlotRecipeVariant>

package/recipes/toggle-slot-recipe.mjs

@@ -31,6 +31,7 @@ export const toggleSlotRecipe = /* @__PURE__ */ Object.assign(toggleSlotRecipeFn
   __recipe__: false,
   __name__: 'toggleSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: toggleSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

package/recipes/tooltip-recipe.d.ts

@@ -10,11 +10,14 @@ type TooltipRecipeVariantMap = {
   [key in keyof TooltipRecipeVariant]: Array<TooltipRecipeVariant[key]>
 }
 
+
+
 export type TooltipRecipeVariantProps = {
   [key in keyof TooltipRecipeVariant]?: ConditionalValue<TooltipRecipeVariant[key]> | undefined
 }
 
 export interface TooltipRecipeRecipe {
+  
   __type: TooltipRecipeVariantProps
   (props?: TooltipRecipeVariantProps): string
   raw: (props?: TooltipRecipeVariantProps) => TooltipRecipeVariantProps

package/recipes/tour-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type TourSlotRecipeVariantMap = {
   [key in keyof TourSlotRecipeVariant]: Array<TourSlotRecipeVariant[key]>
 }
 
+type TourSlotRecipeSlot = "root" | "overlay" | "panel"
+
 export type TourSlotRecipeVariantProps = {
   [key in keyof TourSlotRecipeVariant]?: ConditionalValue<TourSlotRecipeVariant[key]> | undefined
 }
 
 export interface TourSlotRecipeRecipe {
+  __slot: TourSlotRecipeSlot
   __type: TourSlotRecipeVariantProps
-  (props?: TourSlotRecipeVariantProps): Pretty<Record<"root" | "overlay" | "panel", string>>
+  (props?: TourSlotRecipeVariantProps): Pretty<Record<TourSlotRecipeSlot, string>>
   raw: (props?: TourSlotRecipeVariantProps) => TourSlotRecipeVariantProps
   variantMap: TourSlotRecipeVariantMap
   variantKeys: Array<keyof TourSlotRecipeVariant>

package/recipes/tour-slot-recipe.mjs

@@ -31,6 +31,7 @@ export const tourSlotRecipe = /* @__PURE__ */ Object.assign(tourSlotRecipeFn, {
   __recipe__: false,
   __name__: 'tourSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: tourSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

package/recipes/upload-list-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type UploadListSlotRecipeVariantMap = {
   [key in keyof UploadListSlotRecipeVariant]: Array<UploadListSlotRecipeVariant[key]>
 }
 
+type UploadListSlotRecipeSlot = "root" | "titleWrapper" | "actionWrapper"
+
 export type UploadListSlotRecipeVariantProps = {
   [key in keyof UploadListSlotRecipeVariant]?: ConditionalValue<UploadListSlotRecipeVariant[key]> | undefined
 }
 
 export interface UploadListSlotRecipeRecipe {
+  __slot: UploadListSlotRecipeSlot
   __type: UploadListSlotRecipeVariantProps
-  (props?: UploadListSlotRecipeVariantProps): Pretty<Record<"root" | "titleWrapper" | "actionWrapper", string>>
+  (props?: UploadListSlotRecipeVariantProps): Pretty<Record<UploadListSlotRecipeSlot, string>>
   raw: (props?: UploadListSlotRecipeVariantProps) => UploadListSlotRecipeVariantProps
   variantMap: UploadListSlotRecipeVariantMap
   variantKeys: Array<keyof UploadListSlotRecipeVariant>

package/recipes/upload-list-slot-recipe.mjs

@@ -31,6 +31,7 @@ export const uploadListSlotRecipe = /* @__PURE__ */ Object.assign(uploadListSlot
   __recipe__: false,
   __name__: 'uploadListSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: uploadListSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

package/recipes/upload-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type UploadSlotRecipeVariantMap = {
   [key in keyof UploadSlotRecipeVariant]: Array<UploadSlotRecipeVariant[key]>
 }
 
+type UploadSlotRecipeSlot = "root" | "resetButton"
+
 export type UploadSlotRecipeVariantProps = {
   [key in keyof UploadSlotRecipeVariant]?: ConditionalValue<UploadSlotRecipeVariant[key]> | undefined
 }
 
 export interface UploadSlotRecipeRecipe {
+  __slot: UploadSlotRecipeSlot
   __type: UploadSlotRecipeVariantProps
-  (props?: UploadSlotRecipeVariantProps): Pretty<Record<"root" | "resetButton", string>>
+  (props?: UploadSlotRecipeVariantProps): Pretty<Record<UploadSlotRecipeSlot, string>>
   raw: (props?: UploadSlotRecipeVariantProps) => UploadSlotRecipeVariantProps
   variantMap: UploadSlotRecipeVariantMap
   variantKeys: Array<keyof UploadSlotRecipeVariant>

package/recipes/upload-slot-recipe.mjs

@@ -27,6 +27,7 @@ export const uploadSlotRecipe = /* @__PURE__ */ Object.assign(uploadSlotRecipeFn
   __recipe__: false,
   __name__: 'uploadSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: uploadSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

package/recipes/year-item-recipe.d.ts

@@ -10,11 +10,14 @@ type YearItemRecipeVariantMap = {
   [key in keyof YearItemRecipeVariant]: Array<YearItemRecipeVariant[key]>
 }
 
+
+
 export type YearItemRecipeVariantProps = {
   [key in keyof YearItemRecipeVariant]?: ConditionalValue<YearItemRecipeVariant[key]> | undefined
 }
 
 export interface YearItemRecipeRecipe {
+  
   __type: YearItemRecipeVariantProps
   (props?: YearItemRecipeVariantProps): string
   raw: (props?: YearItemRecipeVariantProps) => YearItemRecipeVariantProps

package/types/composition.d.ts

@@ -15,6 +15,8 @@ interface Recursive<T> {
  * -----------------------------------------------------------------------------*/
 
 type TextStyleProperty =
+  | 'color'
+  | 'direction'
   | 'font'
   | 'fontFamily'
   | 'fontFeatureSettings'
@@ -35,6 +37,7 @@ type TextStyleProperty =
   | 'fontVariantPosition'
   | 'fontVariationSettings'
   | 'fontWeight'
+  | 'hangingPunctuation'
   | 'hypens'
   | 'hyphenateCharacter'
   | 'hyphenateLimitChars'
@@ -43,11 +46,17 @@ type TextStyleProperty =
   | 'lineHeight'
   | 'quotes'
   | 'overflowWrap'
+  | 'tabSize'
+  | 'textAlign'
+  | 'textAlignLast'
   | 'textCombineUpright'
   | 'textDecoration'
   | 'textDecorationColor'
   | 'textDecorationLine'
+  | 'textDecorationSkip'
+  | 'textDecorationSkipBox'
   | 'textDecorationSkipInk'
+  | 'textDecorationSkipInset'
   | 'textDecorationStyle'
   | 'textDecorationThickness'
   | 'textEmphasis'
@@ -60,16 +69,21 @@ type TextStyleProperty =
   | 'textOverflow'
   | 'textRendering'
   | 'textShadow'
+  | 'textStroke'
+  | 'textStrokeColor'
+  | 'textStrokeWidth'
   | 'textTransform'
   | 'textUnderlineOffset'
   | 'textUnderlinePosition'
   | 'textWrap'
   | 'textWrapMode'
   | 'textWrapStyle'
+  | 'unicodeBidi'
   | 'verticalAlign'
   | 'whiteSpace'
   | 'wordBreak'
   | 'wordSpacing'
+  | 'writingMode'
 
 export type TextStyle = CompositionStyleObject<TextStyleProperty>
 
@@ -79,17 +93,11 @@ export type TextStyles = Recursive<Token<TextStyle>>
  * Layer styles
  * -----------------------------------------------------------------------------*/
 
-type Placement =
-  | 'Top'
-  | 'Right'
-  | 'Bottom'
-  | 'Left'
-  | 'Inline'
-  | 'Block'
-  | 'InlineStart'
-  | 'InlineEnd'
-  | 'BlockStart'
-  | 'BlockEnd'
+type LogicalPlacement = 'Inline' | 'Block' | 'InlineStart' | 'InlineEnd' | 'BlockStart' | 'BlockEnd'
+
+type PhysicalPlacement = 'Top' | 'Right' | 'Bottom' | 'Left'
+
+type Placement = PhysicalPlacement | LogicalPlacement
 
 type Radius =
   | `Top${'Right' | 'Left'}`
@@ -98,20 +106,80 @@ type Radius =
   | `End${'Start' | 'End'}`
 
 type LayerStyleProperty =
+  | 'aspectRatio'
   | 'background'
   | 'backgroundColor'
   | 'backgroundImage'
-  | 'borderRadius'
   | 'border'
-  | 'borderWidth'
   | 'borderColor'
+  | 'borderImage'
+  | 'borderImageOutset'
+  | 'borderImageRepeat'
+  | 'borderImageSlice'
+  | 'borderImageSource'
+  | 'borderImageWidth'
+  | 'borderRadius'
   | 'borderStyle'
+  | 'borderWidth'
+  | `border${Placement}`
+  | `border${Placement}Color`
+  | `border${Placement}Style`
+  | `border${Placement}Width`
+  | 'borderRadius'
+  | `border${Radius}Radius`
   | 'boxShadow'
+  | 'boxShadowColor'
+  | 'clipPath'
+  | 'color'
+  | 'contain'
+  | 'content'
+  | 'contentVisibility'
+  | 'cursor'
+  | 'display'
   | 'filter'
   | 'backdropFilter'
-  | 'transform'
-  | 'color'
+  | 'height'
+  | 'width'
+  | 'minHeight'
+  | 'minWidth'
+  | 'maxHeight'
+  | 'maxWidth'
+  | `margin${Placement}`
+  | 'inset'
+  | `inset${LogicalPlacement}`
+  | Lowercase<PhysicalPlacement>
+  | 'isolation'
+  | 'mask'
+  | 'maskClip'
+  | 'maskComposite'
+  | 'maskImage'
+  | 'maskMode'
+  | 'maskOrigin'
+  | 'maskPosition'
+  | 'maskRepeat'
+  | 'maskSize'
+  | 'mixBlendMode'
+  | 'objectFit'
+  | 'objectPosition'
   | 'opacity'
+  | 'outline'
+  | 'outlineColor'
+  | 'outlineOffset'
+  | 'outlineStyle'
+  | 'outlineWidth'
+  | 'overflow'
+  | 'overflowX'
+  | 'overflowY'
+  | 'padding'
+  | `padding${Placement}`
+  | 'pointerEvents'
+  | 'position'
+  | 'resize'
+  | 'transform'
+  | 'transition'
+  | 'visibility'
+  | 'willChange'
+  | 'zIndex'
   | 'backgroundBlendMode'
   | 'backgroundAttachment'
   | 'backgroundClip'
@@ -119,14 +187,6 @@ type LayerStyleProperty =
   | 'backgroundPosition'
   | 'backgroundRepeat'
   | 'backgroundSize'
-  | `border${Placement}`
-  | `border${Placement}Width`
-  | 'borderRadius'
-  | `border${Radius}Radius`
-  | `border${Placement}Color`
-  | `border${Placement}Style`
-  | 'padding'
-  | `padding${Placement}`
 
 export type LayerStyle = CompositionStyleObject<LayerStyleProperty>
 

package/types/conditions.d.ts

@@ -46,7 +46,7 @@ export interface Conditions {
 	"_firstLetter": string
 	/** `&::first-line` */
 	"_firstLine": string
-	/** `&::marker` */
+	/** `&:is(::marker, ::-webkit-details-marker)` */
 	"_marker": string
 	/** `&::selection` */
 	"_selection": string
@@ -194,9 +194,9 @@ export interface Conditions {
 	"_lessContrast": string
 	/** `@media (prefers-contrast: more)` */
 	"_moreContrast": string
-	/** `[dir=ltr] &` */
+	/** `:where([dir=ltr], :dir(ltr)) &` */
 	"_ltr": string
-	/** `[dir=rtl] &` */
+	/** `:where([dir=rtl], :dir(rtl)) &` */
 	"_rtl": string
 	/** `&::-webkit-scrollbar` */
 	"_scrollbar": string
@@ -212,6 +212,10 @@ export interface Conditions {
 	"_icon": string
 	/** `@starting-style` */
 	"_starting": string
+	/** `@media (scripting: none)` */
+	"_noscript": string
+	/** `@media (inverted-colors: inverted)` */
+	"_invertedColors": string
 	/** `&:is([aria-collapsed=true], [data-collapsed], [data-state="collapsed"])` */
 	"_collapsed": string
 	/** `&[data-has-icon=true]` */