@calmdown/pyxis-dom 1.0.0-rc.1 → 1.0.0-rc.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist/index.d.ts +1745 -1749
  2. package/dist/index.js.map +1 -1
  3. package/package.json +3 -3
package/dist/index.d.ts CHANGED
@@ -1,4 +1,4 @@
1
- import { Adapter, ElementsType, ExtensionProps, JsxChildren, JsxResult, MaybeReadonlyAtom, MountingGroup, Nil, NodeType, S_NODE_TYPE } from "@calmdown/pyxis/core";
1
+ import { Adapter, ElementsType, ExtensionProps, JsxChildren, JsxResult, MaybeReadAtom, MountingGroup, Nil, NodeType, S_NODE_TYPE } from "@calmdown/pyxis/core";
2
2
  //#region src/component/MathML.d.ts
3
3
  declare function MathML(props: JSX.IntrinsicElements["MathML"]): JsxResult;
4
4
  //#endregion
@@ -7,621 +7,621 @@ declare function Svg(props: JSX.IntrinsicElements["Svg"]): JsxResult;
7
7
  //#endregion
8
8
  //#region src/jsx/baked.d.ts
9
9
  interface CSSStyleDeclarationProps {
10
- readonly accentColor?: MaybeReadonlyAtom<string>;
11
- readonly alignContent?: MaybeReadonlyAtom<string>;
12
- readonly alignItems?: MaybeReadonlyAtom<string>;
13
- readonly alignSelf?: MaybeReadonlyAtom<string>;
14
- readonly alignmentBaseline?: MaybeReadonlyAtom<string>;
15
- readonly all?: MaybeReadonlyAtom<string>;
16
- readonly anchorScope?: MaybeReadonlyAtom<string>;
17
- readonly animation?: MaybeReadonlyAtom<string>;
18
- readonly animationComposition?: MaybeReadonlyAtom<string>;
19
- readonly animationDelay?: MaybeReadonlyAtom<string>;
20
- readonly animationDirection?: MaybeReadonlyAtom<string>;
21
- readonly animationDuration?: MaybeReadonlyAtom<string>;
22
- readonly animationFillMode?: MaybeReadonlyAtom<string>;
23
- readonly animationIterationCount?: MaybeReadonlyAtom<string>;
24
- readonly animationName?: MaybeReadonlyAtom<string>;
25
- readonly animationPlayState?: MaybeReadonlyAtom<string>;
26
- readonly animationRange?: MaybeReadonlyAtom<string>;
27
- readonly animationRangeEnd?: MaybeReadonlyAtom<string>;
28
- readonly animationRangeStart?: MaybeReadonlyAtom<string>;
29
- readonly animationTimeline?: MaybeReadonlyAtom<string>;
30
- readonly animationTimingFunction?: MaybeReadonlyAtom<string>;
31
- readonly appearance?: MaybeReadonlyAtom<string>;
32
- readonly aspectRatio?: MaybeReadonlyAtom<string>;
33
- readonly backdropFilter?: MaybeReadonlyAtom<string>;
34
- readonly backfaceVisibility?: MaybeReadonlyAtom<string>;
35
- readonly background?: MaybeReadonlyAtom<string>;
36
- readonly backgroundAttachment?: MaybeReadonlyAtom<string>;
37
- readonly backgroundBlendMode?: MaybeReadonlyAtom<string>;
38
- readonly backgroundClip?: MaybeReadonlyAtom<string>;
39
- readonly backgroundColor?: MaybeReadonlyAtom<string>;
40
- readonly backgroundImage?: MaybeReadonlyAtom<string>;
41
- readonly backgroundOrigin?: MaybeReadonlyAtom<string>;
42
- readonly backgroundPosition?: MaybeReadonlyAtom<string>;
43
- readonly backgroundPositionX?: MaybeReadonlyAtom<string>;
44
- readonly backgroundPositionY?: MaybeReadonlyAtom<string>;
45
- readonly backgroundRepeat?: MaybeReadonlyAtom<string>;
46
- readonly backgroundSize?: MaybeReadonlyAtom<string>;
47
- readonly baselineShift?: MaybeReadonlyAtom<string>;
48
- readonly baselineSource?: MaybeReadonlyAtom<string>;
49
- readonly blockSize?: MaybeReadonlyAtom<string>;
50
- readonly border?: MaybeReadonlyAtom<string>;
51
- readonly borderBlock?: MaybeReadonlyAtom<string>;
52
- readonly borderBlockColor?: MaybeReadonlyAtom<string>;
53
- readonly borderBlockEnd?: MaybeReadonlyAtom<string>;
54
- readonly borderBlockEndColor?: MaybeReadonlyAtom<string>;
55
- readonly borderBlockEndStyle?: MaybeReadonlyAtom<string>;
56
- readonly borderBlockEndWidth?: MaybeReadonlyAtom<string>;
57
- readonly borderBlockStart?: MaybeReadonlyAtom<string>;
58
- readonly borderBlockStartColor?: MaybeReadonlyAtom<string>;
59
- readonly borderBlockStartStyle?: MaybeReadonlyAtom<string>;
60
- readonly borderBlockStartWidth?: MaybeReadonlyAtom<string>;
61
- readonly borderBlockStyle?: MaybeReadonlyAtom<string>;
62
- readonly borderBlockWidth?: MaybeReadonlyAtom<string>;
63
- readonly borderBottom?: MaybeReadonlyAtom<string>;
64
- readonly borderBottomColor?: MaybeReadonlyAtom<string>;
65
- readonly borderBottomLeftRadius?: MaybeReadonlyAtom<string>;
66
- readonly borderBottomRightRadius?: MaybeReadonlyAtom<string>;
67
- readonly borderBottomStyle?: MaybeReadonlyAtom<string>;
68
- readonly borderBottomWidth?: MaybeReadonlyAtom<string>;
69
- readonly borderCollapse?: MaybeReadonlyAtom<string>;
70
- readonly borderColor?: MaybeReadonlyAtom<string>;
71
- readonly borderEndEndRadius?: MaybeReadonlyAtom<string>;
72
- readonly borderEndStartRadius?: MaybeReadonlyAtom<string>;
73
- readonly borderImage?: MaybeReadonlyAtom<string>;
74
- readonly borderImageOutset?: MaybeReadonlyAtom<string>;
75
- readonly borderImageRepeat?: MaybeReadonlyAtom<string>;
76
- readonly borderImageSlice?: MaybeReadonlyAtom<string>;
77
- readonly borderImageSource?: MaybeReadonlyAtom<string>;
78
- readonly borderImageWidth?: MaybeReadonlyAtom<string>;
79
- readonly borderInline?: MaybeReadonlyAtom<string>;
80
- readonly borderInlineColor?: MaybeReadonlyAtom<string>;
81
- readonly borderInlineEnd?: MaybeReadonlyAtom<string>;
82
- readonly borderInlineEndColor?: MaybeReadonlyAtom<string>;
83
- readonly borderInlineEndStyle?: MaybeReadonlyAtom<string>;
84
- readonly borderInlineEndWidth?: MaybeReadonlyAtom<string>;
85
- readonly borderInlineStart?: MaybeReadonlyAtom<string>;
86
- readonly borderInlineStartColor?: MaybeReadonlyAtom<string>;
87
- readonly borderInlineStartStyle?: MaybeReadonlyAtom<string>;
88
- readonly borderInlineStartWidth?: MaybeReadonlyAtom<string>;
89
- readonly borderInlineStyle?: MaybeReadonlyAtom<string>;
90
- readonly borderInlineWidth?: MaybeReadonlyAtom<string>;
91
- readonly borderLeft?: MaybeReadonlyAtom<string>;
92
- readonly borderLeftColor?: MaybeReadonlyAtom<string>;
93
- readonly borderLeftStyle?: MaybeReadonlyAtom<string>;
94
- readonly borderLeftWidth?: MaybeReadonlyAtom<string>;
95
- readonly borderRadius?: MaybeReadonlyAtom<string>;
96
- readonly borderRight?: MaybeReadonlyAtom<string>;
97
- readonly borderRightColor?: MaybeReadonlyAtom<string>;
98
- readonly borderRightStyle?: MaybeReadonlyAtom<string>;
99
- readonly borderRightWidth?: MaybeReadonlyAtom<string>;
100
- readonly borderSpacing?: MaybeReadonlyAtom<string>;
101
- readonly borderStartEndRadius?: MaybeReadonlyAtom<string>;
102
- readonly borderStartStartRadius?: MaybeReadonlyAtom<string>;
103
- readonly borderStyle?: MaybeReadonlyAtom<string>;
104
- readonly borderTop?: MaybeReadonlyAtom<string>;
105
- readonly borderTopColor?: MaybeReadonlyAtom<string>;
106
- readonly borderTopLeftRadius?: MaybeReadonlyAtom<string>;
107
- readonly borderTopRightRadius?: MaybeReadonlyAtom<string>;
108
- readonly borderTopStyle?: MaybeReadonlyAtom<string>;
109
- readonly borderTopWidth?: MaybeReadonlyAtom<string>;
110
- readonly borderWidth?: MaybeReadonlyAtom<string>;
111
- readonly bottom?: MaybeReadonlyAtom<string>;
112
- readonly boxDecorationBreak?: MaybeReadonlyAtom<string>;
113
- readonly boxShadow?: MaybeReadonlyAtom<string>;
114
- readonly boxSizing?: MaybeReadonlyAtom<string>;
115
- readonly breakAfter?: MaybeReadonlyAtom<string>;
116
- readonly breakBefore?: MaybeReadonlyAtom<string>;
117
- readonly breakInside?: MaybeReadonlyAtom<string>;
118
- readonly captionSide?: MaybeReadonlyAtom<string>;
119
- readonly caretColor?: MaybeReadonlyAtom<string>;
120
- readonly clear?: MaybeReadonlyAtom<string>;
121
- readonly clipPath?: MaybeReadonlyAtom<string>;
122
- readonly clipRule?: MaybeReadonlyAtom<string>;
123
- readonly color?: MaybeReadonlyAtom<string>;
124
- readonly colorInterpolation?: MaybeReadonlyAtom<string>;
125
- readonly colorInterpolationFilters?: MaybeReadonlyAtom<string>;
126
- readonly colorScheme?: MaybeReadonlyAtom<string>;
127
- readonly columnCount?: MaybeReadonlyAtom<string>;
128
- readonly columnFill?: MaybeReadonlyAtom<string>;
129
- readonly columnGap?: MaybeReadonlyAtom<string>;
130
- readonly columnRule?: MaybeReadonlyAtom<string>;
131
- readonly columnRuleColor?: MaybeReadonlyAtom<string>;
132
- readonly columnRuleStyle?: MaybeReadonlyAtom<string>;
133
- readonly columnRuleWidth?: MaybeReadonlyAtom<string>;
134
- readonly columnSpan?: MaybeReadonlyAtom<string>;
135
- readonly columnWidth?: MaybeReadonlyAtom<string>;
136
- readonly columns?: MaybeReadonlyAtom<string>;
137
- readonly contain?: MaybeReadonlyAtom<string>;
138
- readonly containIntrinsicBlockSize?: MaybeReadonlyAtom<string>;
139
- readonly containIntrinsicHeight?: MaybeReadonlyAtom<string>;
140
- readonly containIntrinsicInlineSize?: MaybeReadonlyAtom<string>;
141
- readonly containIntrinsicSize?: MaybeReadonlyAtom<string>;
142
- readonly containIntrinsicWidth?: MaybeReadonlyAtom<string>;
143
- readonly container?: MaybeReadonlyAtom<string>;
144
- readonly containerName?: MaybeReadonlyAtom<string>;
145
- readonly containerType?: MaybeReadonlyAtom<string>;
146
- readonly content?: MaybeReadonlyAtom<string>;
147
- readonly contentVisibility?: MaybeReadonlyAtom<string>;
148
- readonly counterIncrement?: MaybeReadonlyAtom<string>;
149
- readonly counterReset?: MaybeReadonlyAtom<string>;
150
- readonly counterSet?: MaybeReadonlyAtom<string>;
151
- readonly cursor?: MaybeReadonlyAtom<string>;
152
- readonly cx?: MaybeReadonlyAtom<string>;
153
- readonly cy?: MaybeReadonlyAtom<string>;
154
- readonly d?: MaybeReadonlyAtom<string>;
155
- readonly direction?: MaybeReadonlyAtom<string>;
156
- readonly display?: MaybeReadonlyAtom<string>;
157
- readonly dominantBaseline?: MaybeReadonlyAtom<string>;
158
- readonly dynamicRangeLimit?: MaybeReadonlyAtom<string>;
159
- readonly emptyCells?: MaybeReadonlyAtom<string>;
160
- readonly fieldSizing?: MaybeReadonlyAtom<string>;
161
- readonly fill?: MaybeReadonlyAtom<string>;
162
- readonly fillOpacity?: MaybeReadonlyAtom<string>;
163
- readonly fillRule?: MaybeReadonlyAtom<string>;
164
- readonly filter?: MaybeReadonlyAtom<string>;
165
- readonly flex?: MaybeReadonlyAtom<string>;
166
- readonly flexBasis?: MaybeReadonlyAtom<string>;
167
- readonly flexDirection?: MaybeReadonlyAtom<string>;
168
- readonly flexFlow?: MaybeReadonlyAtom<string>;
169
- readonly flexGrow?: MaybeReadonlyAtom<string>;
170
- readonly flexShrink?: MaybeReadonlyAtom<string>;
171
- readonly flexWrap?: MaybeReadonlyAtom<string>;
172
- readonly float?: MaybeReadonlyAtom<string>;
173
- readonly floodColor?: MaybeReadonlyAtom<string>;
174
- readonly floodOpacity?: MaybeReadonlyAtom<string>;
175
- readonly font?: MaybeReadonlyAtom<string>;
176
- readonly fontFamily?: MaybeReadonlyAtom<string>;
177
- readonly fontFeatureSettings?: MaybeReadonlyAtom<string>;
178
- readonly fontKerning?: MaybeReadonlyAtom<string>;
179
- readonly fontLanguageOverride?: MaybeReadonlyAtom<string>;
180
- readonly fontOpticalSizing?: MaybeReadonlyAtom<string>;
181
- readonly fontPalette?: MaybeReadonlyAtom<string>;
182
- readonly fontSize?: MaybeReadonlyAtom<string>;
183
- readonly fontSizeAdjust?: MaybeReadonlyAtom<string>;
184
- readonly fontStyle?: MaybeReadonlyAtom<string>;
185
- readonly fontSynthesis?: MaybeReadonlyAtom<string>;
186
- readonly fontSynthesisSmallCaps?: MaybeReadonlyAtom<string>;
187
- readonly fontSynthesisStyle?: MaybeReadonlyAtom<string>;
188
- readonly fontSynthesisWeight?: MaybeReadonlyAtom<string>;
189
- readonly fontVariant?: MaybeReadonlyAtom<string>;
190
- readonly fontVariantAlternates?: MaybeReadonlyAtom<string>;
191
- readonly fontVariantCaps?: MaybeReadonlyAtom<string>;
192
- readonly fontVariantEastAsian?: MaybeReadonlyAtom<string>;
193
- readonly fontVariantEmoji?: MaybeReadonlyAtom<string>;
194
- readonly fontVariantLigatures?: MaybeReadonlyAtom<string>;
195
- readonly fontVariantNumeric?: MaybeReadonlyAtom<string>;
196
- readonly fontVariantPosition?: MaybeReadonlyAtom<string>;
197
- readonly fontVariationSettings?: MaybeReadonlyAtom<string>;
198
- readonly fontWeight?: MaybeReadonlyAtom<string>;
199
- readonly forcedColorAdjust?: MaybeReadonlyAtom<string>;
200
- readonly gap?: MaybeReadonlyAtom<string>;
201
- readonly grid?: MaybeReadonlyAtom<string>;
202
- readonly gridArea?: MaybeReadonlyAtom<string>;
203
- readonly gridAutoColumns?: MaybeReadonlyAtom<string>;
204
- readonly gridAutoFlow?: MaybeReadonlyAtom<string>;
205
- readonly gridAutoRows?: MaybeReadonlyAtom<string>;
206
- readonly gridColumn?: MaybeReadonlyAtom<string>;
207
- readonly gridColumnEnd?: MaybeReadonlyAtom<string>;
208
- readonly gridColumnStart?: MaybeReadonlyAtom<string>;
209
- readonly gridRow?: MaybeReadonlyAtom<string>;
210
- readonly gridRowEnd?: MaybeReadonlyAtom<string>;
211
- readonly gridRowStart?: MaybeReadonlyAtom<string>;
212
- readonly gridTemplate?: MaybeReadonlyAtom<string>;
213
- readonly gridTemplateAreas?: MaybeReadonlyAtom<string>;
214
- readonly gridTemplateColumns?: MaybeReadonlyAtom<string>;
215
- readonly gridTemplateRows?: MaybeReadonlyAtom<string>;
216
- readonly height?: MaybeReadonlyAtom<string>;
217
- readonly hyphenateCharacter?: MaybeReadonlyAtom<string>;
218
- readonly hyphenateLimitChars?: MaybeReadonlyAtom<string>;
219
- readonly hyphens?: MaybeReadonlyAtom<string>;
220
- readonly imageRendering?: MaybeReadonlyAtom<string>;
221
- readonly inlineSize?: MaybeReadonlyAtom<string>;
222
- readonly inset?: MaybeReadonlyAtom<string>;
223
- readonly insetBlock?: MaybeReadonlyAtom<string>;
224
- readonly insetBlockEnd?: MaybeReadonlyAtom<string>;
225
- readonly insetBlockStart?: MaybeReadonlyAtom<string>;
226
- readonly insetInline?: MaybeReadonlyAtom<string>;
227
- readonly insetInlineEnd?: MaybeReadonlyAtom<string>;
228
- readonly insetInlineStart?: MaybeReadonlyAtom<string>;
229
- readonly isolation?: MaybeReadonlyAtom<string>;
230
- readonly justifyContent?: MaybeReadonlyAtom<string>;
231
- readonly justifyItems?: MaybeReadonlyAtom<string>;
232
- readonly justifySelf?: MaybeReadonlyAtom<string>;
233
- readonly left?: MaybeReadonlyAtom<string>;
234
- readonly letterSpacing?: MaybeReadonlyAtom<string>;
235
- readonly lightingColor?: MaybeReadonlyAtom<string>;
236
- readonly lineBreak?: MaybeReadonlyAtom<string>;
237
- readonly lineHeight?: MaybeReadonlyAtom<string>;
238
- readonly listStyle?: MaybeReadonlyAtom<string>;
239
- readonly listStyleImage?: MaybeReadonlyAtom<string>;
240
- readonly listStylePosition?: MaybeReadonlyAtom<string>;
241
- readonly listStyleType?: MaybeReadonlyAtom<string>;
242
- readonly margin?: MaybeReadonlyAtom<string>;
243
- readonly marginBlock?: MaybeReadonlyAtom<string>;
244
- readonly marginBlockEnd?: MaybeReadonlyAtom<string>;
245
- readonly marginBlockStart?: MaybeReadonlyAtom<string>;
246
- readonly marginBottom?: MaybeReadonlyAtom<string>;
247
- readonly marginInline?: MaybeReadonlyAtom<string>;
248
- readonly marginInlineEnd?: MaybeReadonlyAtom<string>;
249
- readonly marginInlineStart?: MaybeReadonlyAtom<string>;
250
- readonly marginLeft?: MaybeReadonlyAtom<string>;
251
- readonly marginRight?: MaybeReadonlyAtom<string>;
252
- readonly marginTop?: MaybeReadonlyAtom<string>;
253
- readonly marker?: MaybeReadonlyAtom<string>;
254
- readonly markerEnd?: MaybeReadonlyAtom<string>;
255
- readonly markerMid?: MaybeReadonlyAtom<string>;
256
- readonly markerStart?: MaybeReadonlyAtom<string>;
257
- readonly mask?: MaybeReadonlyAtom<string>;
258
- readonly maskClip?: MaybeReadonlyAtom<string>;
259
- readonly maskComposite?: MaybeReadonlyAtom<string>;
260
- readonly maskImage?: MaybeReadonlyAtom<string>;
261
- readonly maskMode?: MaybeReadonlyAtom<string>;
262
- readonly maskOrigin?: MaybeReadonlyAtom<string>;
263
- readonly maskPosition?: MaybeReadonlyAtom<string>;
264
- readonly maskRepeat?: MaybeReadonlyAtom<string>;
265
- readonly maskSize?: MaybeReadonlyAtom<string>;
266
- readonly maskType?: MaybeReadonlyAtom<string>;
267
- readonly mathDepth?: MaybeReadonlyAtom<string>;
268
- readonly mathShift?: MaybeReadonlyAtom<string>;
269
- readonly mathStyle?: MaybeReadonlyAtom<string>;
270
- readonly maxBlockSize?: MaybeReadonlyAtom<string>;
271
- readonly maxHeight?: MaybeReadonlyAtom<string>;
272
- readonly maxInlineSize?: MaybeReadonlyAtom<string>;
273
- readonly maxWidth?: MaybeReadonlyAtom<string>;
274
- readonly minBlockSize?: MaybeReadonlyAtom<string>;
275
- readonly minHeight?: MaybeReadonlyAtom<string>;
276
- readonly minInlineSize?: MaybeReadonlyAtom<string>;
277
- readonly minWidth?: MaybeReadonlyAtom<string>;
278
- readonly mixBlendMode?: MaybeReadonlyAtom<string>;
279
- readonly objectFit?: MaybeReadonlyAtom<string>;
280
- readonly objectPosition?: MaybeReadonlyAtom<string>;
281
- readonly offset?: MaybeReadonlyAtom<string>;
282
- readonly offsetAnchor?: MaybeReadonlyAtom<string>;
283
- readonly offsetDistance?: MaybeReadonlyAtom<string>;
284
- readonly offsetPath?: MaybeReadonlyAtom<string>;
285
- readonly offsetPosition?: MaybeReadonlyAtom<string>;
286
- readonly offsetRotate?: MaybeReadonlyAtom<string>;
287
- readonly opacity?: MaybeReadonlyAtom<string>;
288
- readonly order?: MaybeReadonlyAtom<string>;
289
- readonly orphans?: MaybeReadonlyAtom<string>;
290
- readonly outline?: MaybeReadonlyAtom<string>;
291
- readonly outlineColor?: MaybeReadonlyAtom<string>;
292
- readonly outlineOffset?: MaybeReadonlyAtom<string>;
293
- readonly outlineStyle?: MaybeReadonlyAtom<string>;
294
- readonly outlineWidth?: MaybeReadonlyAtom<string>;
295
- readonly overflow?: MaybeReadonlyAtom<string>;
296
- readonly overflowAnchor?: MaybeReadonlyAtom<string>;
297
- readonly overflowBlock?: MaybeReadonlyAtom<string>;
298
- readonly overflowClipMargin?: MaybeReadonlyAtom<string>;
299
- readonly overflowInline?: MaybeReadonlyAtom<string>;
300
- readonly overflowWrap?: MaybeReadonlyAtom<string>;
301
- readonly overflowX?: MaybeReadonlyAtom<string>;
302
- readonly overflowY?: MaybeReadonlyAtom<string>;
303
- readonly overscrollBehavior?: MaybeReadonlyAtom<string>;
304
- readonly overscrollBehaviorBlock?: MaybeReadonlyAtom<string>;
305
- readonly overscrollBehaviorInline?: MaybeReadonlyAtom<string>;
306
- readonly overscrollBehaviorX?: MaybeReadonlyAtom<string>;
307
- readonly overscrollBehaviorY?: MaybeReadonlyAtom<string>;
308
- readonly padding?: MaybeReadonlyAtom<string>;
309
- readonly paddingBlock?: MaybeReadonlyAtom<string>;
310
- readonly paddingBlockEnd?: MaybeReadonlyAtom<string>;
311
- readonly paddingBlockStart?: MaybeReadonlyAtom<string>;
312
- readonly paddingBottom?: MaybeReadonlyAtom<string>;
313
- readonly paddingInline?: MaybeReadonlyAtom<string>;
314
- readonly paddingInlineEnd?: MaybeReadonlyAtom<string>;
315
- readonly paddingInlineStart?: MaybeReadonlyAtom<string>;
316
- readonly paddingLeft?: MaybeReadonlyAtom<string>;
317
- readonly paddingRight?: MaybeReadonlyAtom<string>;
318
- readonly paddingTop?: MaybeReadonlyAtom<string>;
319
- readonly page?: MaybeReadonlyAtom<string>;
320
- readonly paintOrder?: MaybeReadonlyAtom<string>;
321
- readonly perspective?: MaybeReadonlyAtom<string>;
322
- readonly perspectiveOrigin?: MaybeReadonlyAtom<string>;
323
- readonly placeContent?: MaybeReadonlyAtom<string>;
324
- readonly placeItems?: MaybeReadonlyAtom<string>;
325
- readonly placeSelf?: MaybeReadonlyAtom<string>;
326
- readonly pointerEvents?: MaybeReadonlyAtom<string>;
327
- readonly position?: MaybeReadonlyAtom<string>;
328
- readonly positionTry?: MaybeReadonlyAtom<string>;
329
- readonly positionTryFallbacks?: MaybeReadonlyAtom<string>;
330
- readonly positionTryOrder?: MaybeReadonlyAtom<string>;
331
- readonly positionVisibility?: MaybeReadonlyAtom<string>;
332
- readonly printColorAdjust?: MaybeReadonlyAtom<string>;
333
- readonly quotes?: MaybeReadonlyAtom<string>;
334
- readonly r?: MaybeReadonlyAtom<string>;
335
- readonly resize?: MaybeReadonlyAtom<string>;
336
- readonly right?: MaybeReadonlyAtom<string>;
337
- readonly rotate?: MaybeReadonlyAtom<string>;
338
- readonly rowGap?: MaybeReadonlyAtom<string>;
339
- readonly rubyAlign?: MaybeReadonlyAtom<string>;
340
- readonly rubyPosition?: MaybeReadonlyAtom<string>;
341
- readonly rx?: MaybeReadonlyAtom<string>;
342
- readonly ry?: MaybeReadonlyAtom<string>;
343
- readonly scale?: MaybeReadonlyAtom<string>;
344
- readonly scrollBehavior?: MaybeReadonlyAtom<string>;
345
- readonly scrollMargin?: MaybeReadonlyAtom<string>;
346
- readonly scrollMarginBlock?: MaybeReadonlyAtom<string>;
347
- readonly scrollMarginBlockEnd?: MaybeReadonlyAtom<string>;
348
- readonly scrollMarginBlockStart?: MaybeReadonlyAtom<string>;
349
- readonly scrollMarginBottom?: MaybeReadonlyAtom<string>;
350
- readonly scrollMarginInline?: MaybeReadonlyAtom<string>;
351
- readonly scrollMarginInlineEnd?: MaybeReadonlyAtom<string>;
352
- readonly scrollMarginInlineStart?: MaybeReadonlyAtom<string>;
353
- readonly scrollMarginLeft?: MaybeReadonlyAtom<string>;
354
- readonly scrollMarginRight?: MaybeReadonlyAtom<string>;
355
- readonly scrollMarginTop?: MaybeReadonlyAtom<string>;
356
- readonly scrollPadding?: MaybeReadonlyAtom<string>;
357
- readonly scrollPaddingBlock?: MaybeReadonlyAtom<string>;
358
- readonly scrollPaddingBlockEnd?: MaybeReadonlyAtom<string>;
359
- readonly scrollPaddingBlockStart?: MaybeReadonlyAtom<string>;
360
- readonly scrollPaddingBottom?: MaybeReadonlyAtom<string>;
361
- readonly scrollPaddingInline?: MaybeReadonlyAtom<string>;
362
- readonly scrollPaddingInlineEnd?: MaybeReadonlyAtom<string>;
363
- readonly scrollPaddingInlineStart?: MaybeReadonlyAtom<string>;
364
- readonly scrollPaddingLeft?: MaybeReadonlyAtom<string>;
365
- readonly scrollPaddingRight?: MaybeReadonlyAtom<string>;
366
- readonly scrollPaddingTop?: MaybeReadonlyAtom<string>;
367
- readonly scrollSnapAlign?: MaybeReadonlyAtom<string>;
368
- readonly scrollSnapStop?: MaybeReadonlyAtom<string>;
369
- readonly scrollSnapType?: MaybeReadonlyAtom<string>;
370
- readonly scrollTimeline?: MaybeReadonlyAtom<string>;
371
- readonly scrollTimelineAxis?: MaybeReadonlyAtom<string>;
372
- readonly scrollTimelineName?: MaybeReadonlyAtom<string>;
373
- readonly scrollbarColor?: MaybeReadonlyAtom<string>;
374
- readonly scrollbarGutter?: MaybeReadonlyAtom<string>;
375
- readonly scrollbarWidth?: MaybeReadonlyAtom<string>;
376
- readonly shapeImageThreshold?: MaybeReadonlyAtom<string>;
377
- readonly shapeMargin?: MaybeReadonlyAtom<string>;
378
- readonly shapeOutside?: MaybeReadonlyAtom<string>;
379
- readonly shapeRendering?: MaybeReadonlyAtom<string>;
380
- readonly stopColor?: MaybeReadonlyAtom<string>;
381
- readonly stopOpacity?: MaybeReadonlyAtom<string>;
382
- readonly stroke?: MaybeReadonlyAtom<string>;
383
- readonly strokeDasharray?: MaybeReadonlyAtom<string>;
384
- readonly strokeDashoffset?: MaybeReadonlyAtom<string>;
385
- readonly strokeLinecap?: MaybeReadonlyAtom<string>;
386
- readonly strokeLinejoin?: MaybeReadonlyAtom<string>;
387
- readonly strokeMiterlimit?: MaybeReadonlyAtom<string>;
388
- readonly strokeOpacity?: MaybeReadonlyAtom<string>;
389
- readonly strokeWidth?: MaybeReadonlyAtom<string>;
390
- readonly tabSize?: MaybeReadonlyAtom<string>;
391
- readonly tableLayout?: MaybeReadonlyAtom<string>;
392
- readonly textAlign?: MaybeReadonlyAtom<string>;
393
- readonly textAlignLast?: MaybeReadonlyAtom<string>;
394
- readonly textAnchor?: MaybeReadonlyAtom<string>;
395
- readonly textAutospace?: MaybeReadonlyAtom<string>;
396
- readonly textBox?: MaybeReadonlyAtom<string>;
397
- readonly textBoxEdge?: MaybeReadonlyAtom<string>;
398
- readonly textBoxTrim?: MaybeReadonlyAtom<string>;
399
- readonly textCombineUpright?: MaybeReadonlyAtom<string>;
400
- readonly textDecoration?: MaybeReadonlyAtom<string>;
401
- readonly textDecorationColor?: MaybeReadonlyAtom<string>;
402
- readonly textDecorationLine?: MaybeReadonlyAtom<string>;
403
- readonly textDecorationSkipInk?: MaybeReadonlyAtom<string>;
404
- readonly textDecorationStyle?: MaybeReadonlyAtom<string>;
405
- readonly textDecorationThickness?: MaybeReadonlyAtom<string>;
406
- readonly textEmphasis?: MaybeReadonlyAtom<string>;
407
- readonly textEmphasisColor?: MaybeReadonlyAtom<string>;
408
- readonly textEmphasisPosition?: MaybeReadonlyAtom<string>;
409
- readonly textEmphasisStyle?: MaybeReadonlyAtom<string>;
410
- readonly textIndent?: MaybeReadonlyAtom<string>;
411
- readonly textJustify?: MaybeReadonlyAtom<string>;
412
- readonly textOrientation?: MaybeReadonlyAtom<string>;
413
- readonly textOverflow?: MaybeReadonlyAtom<string>;
414
- readonly textRendering?: MaybeReadonlyAtom<string>;
415
- readonly textShadow?: MaybeReadonlyAtom<string>;
416
- readonly textTransform?: MaybeReadonlyAtom<string>;
417
- readonly textUnderlineOffset?: MaybeReadonlyAtom<string>;
418
- readonly textUnderlinePosition?: MaybeReadonlyAtom<string>;
419
- readonly textWrap?: MaybeReadonlyAtom<string>;
420
- readonly textWrapMode?: MaybeReadonlyAtom<string>;
421
- readonly textWrapStyle?: MaybeReadonlyAtom<string>;
422
- readonly timelineScope?: MaybeReadonlyAtom<string>;
423
- readonly top?: MaybeReadonlyAtom<string>;
424
- readonly touchAction?: MaybeReadonlyAtom<string>;
425
- readonly transform?: MaybeReadonlyAtom<string>;
426
- readonly transformBox?: MaybeReadonlyAtom<string>;
427
- readonly transformOrigin?: MaybeReadonlyAtom<string>;
428
- readonly transformStyle?: MaybeReadonlyAtom<string>;
429
- readonly transition?: MaybeReadonlyAtom<string>;
430
- readonly transitionBehavior?: MaybeReadonlyAtom<string>;
431
- readonly transitionDelay?: MaybeReadonlyAtom<string>;
432
- readonly transitionDuration?: MaybeReadonlyAtom<string>;
433
- readonly transitionProperty?: MaybeReadonlyAtom<string>;
434
- readonly transitionTimingFunction?: MaybeReadonlyAtom<string>;
435
- readonly translate?: MaybeReadonlyAtom<string>;
436
- readonly unicodeBidi?: MaybeReadonlyAtom<string>;
437
- readonly userSelect?: MaybeReadonlyAtom<string>;
438
- readonly vectorEffect?: MaybeReadonlyAtom<string>;
439
- readonly verticalAlign?: MaybeReadonlyAtom<string>;
440
- readonly viewTimeline?: MaybeReadonlyAtom<string>;
441
- readonly viewTimelineAxis?: MaybeReadonlyAtom<string>;
442
- readonly viewTimelineInset?: MaybeReadonlyAtom<string>;
443
- readonly viewTimelineName?: MaybeReadonlyAtom<string>;
444
- readonly viewTransitionClass?: MaybeReadonlyAtom<string>;
445
- readonly viewTransitionName?: MaybeReadonlyAtom<string>;
446
- readonly visibility?: MaybeReadonlyAtom<string>;
447
- readonly webkitLineClamp?: MaybeReadonlyAtom<string>;
448
- readonly webkitTextFillColor?: MaybeReadonlyAtom<string>;
449
- readonly webkitTextStroke?: MaybeReadonlyAtom<string>;
450
- readonly webkitTextStrokeColor?: MaybeReadonlyAtom<string>;
451
- readonly webkitTextStrokeWidth?: MaybeReadonlyAtom<string>;
452
- readonly whiteSpace?: MaybeReadonlyAtom<string>;
453
- readonly whiteSpaceCollapse?: MaybeReadonlyAtom<string>;
454
- readonly widows?: MaybeReadonlyAtom<string>;
455
- readonly width?: MaybeReadonlyAtom<string>;
456
- readonly willChange?: MaybeReadonlyAtom<string>;
457
- readonly wordBreak?: MaybeReadonlyAtom<string>;
458
- readonly wordSpacing?: MaybeReadonlyAtom<string>;
459
- readonly writingMode?: MaybeReadonlyAtom<string>;
460
- readonly x?: MaybeReadonlyAtom<string>;
461
- readonly y?: MaybeReadonlyAtom<string>;
462
- readonly zIndex?: MaybeReadonlyAtom<string>;
463
- readonly zoom?: MaybeReadonlyAtom<string>;
464
- readonly anchorName?: MaybeReadonlyAtom<string>;
465
- readonly positionAnchor?: MaybeReadonlyAtom<string>;
466
- readonly positionArea?: MaybeReadonlyAtom<string>;
10
+ readonly accentColor?: MaybeReadAtom<string>;
11
+ readonly alignContent?: MaybeReadAtom<string>;
12
+ readonly alignItems?: MaybeReadAtom<string>;
13
+ readonly alignSelf?: MaybeReadAtom<string>;
14
+ readonly alignmentBaseline?: MaybeReadAtom<string>;
15
+ readonly all?: MaybeReadAtom<string>;
16
+ readonly anchorScope?: MaybeReadAtom<string>;
17
+ readonly animation?: MaybeReadAtom<string>;
18
+ readonly animationComposition?: MaybeReadAtom<string>;
19
+ readonly animationDelay?: MaybeReadAtom<string>;
20
+ readonly animationDirection?: MaybeReadAtom<string>;
21
+ readonly animationDuration?: MaybeReadAtom<string>;
22
+ readonly animationFillMode?: MaybeReadAtom<string>;
23
+ readonly animationIterationCount?: MaybeReadAtom<string>;
24
+ readonly animationName?: MaybeReadAtom<string>;
25
+ readonly animationPlayState?: MaybeReadAtom<string>;
26
+ readonly animationRange?: MaybeReadAtom<string>;
27
+ readonly animationRangeEnd?: MaybeReadAtom<string>;
28
+ readonly animationRangeStart?: MaybeReadAtom<string>;
29
+ readonly animationTimeline?: MaybeReadAtom<string>;
30
+ readonly animationTimingFunction?: MaybeReadAtom<string>;
31
+ readonly appearance?: MaybeReadAtom<string>;
32
+ readonly aspectRatio?: MaybeReadAtom<string>;
33
+ readonly backdropFilter?: MaybeReadAtom<string>;
34
+ readonly backfaceVisibility?: MaybeReadAtom<string>;
35
+ readonly background?: MaybeReadAtom<string>;
36
+ readonly backgroundAttachment?: MaybeReadAtom<string>;
37
+ readonly backgroundBlendMode?: MaybeReadAtom<string>;
38
+ readonly backgroundClip?: MaybeReadAtom<string>;
39
+ readonly backgroundColor?: MaybeReadAtom<string>;
40
+ readonly backgroundImage?: MaybeReadAtom<string>;
41
+ readonly backgroundOrigin?: MaybeReadAtom<string>;
42
+ readonly backgroundPosition?: MaybeReadAtom<string>;
43
+ readonly backgroundPositionX?: MaybeReadAtom<string>;
44
+ readonly backgroundPositionY?: MaybeReadAtom<string>;
45
+ readonly backgroundRepeat?: MaybeReadAtom<string>;
46
+ readonly backgroundSize?: MaybeReadAtom<string>;
47
+ readonly baselineShift?: MaybeReadAtom<string>;
48
+ readonly baselineSource?: MaybeReadAtom<string>;
49
+ readonly blockSize?: MaybeReadAtom<string>;
50
+ readonly border?: MaybeReadAtom<string>;
51
+ readonly borderBlock?: MaybeReadAtom<string>;
52
+ readonly borderBlockColor?: MaybeReadAtom<string>;
53
+ readonly borderBlockEnd?: MaybeReadAtom<string>;
54
+ readonly borderBlockEndColor?: MaybeReadAtom<string>;
55
+ readonly borderBlockEndStyle?: MaybeReadAtom<string>;
56
+ readonly borderBlockEndWidth?: MaybeReadAtom<string>;
57
+ readonly borderBlockStart?: MaybeReadAtom<string>;
58
+ readonly borderBlockStartColor?: MaybeReadAtom<string>;
59
+ readonly borderBlockStartStyle?: MaybeReadAtom<string>;
60
+ readonly borderBlockStartWidth?: MaybeReadAtom<string>;
61
+ readonly borderBlockStyle?: MaybeReadAtom<string>;
62
+ readonly borderBlockWidth?: MaybeReadAtom<string>;
63
+ readonly borderBottom?: MaybeReadAtom<string>;
64
+ readonly borderBottomColor?: MaybeReadAtom<string>;
65
+ readonly borderBottomLeftRadius?: MaybeReadAtom<string>;
66
+ readonly borderBottomRightRadius?: MaybeReadAtom<string>;
67
+ readonly borderBottomStyle?: MaybeReadAtom<string>;
68
+ readonly borderBottomWidth?: MaybeReadAtom<string>;
69
+ readonly borderCollapse?: MaybeReadAtom<string>;
70
+ readonly borderColor?: MaybeReadAtom<string>;
71
+ readonly borderEndEndRadius?: MaybeReadAtom<string>;
72
+ readonly borderEndStartRadius?: MaybeReadAtom<string>;
73
+ readonly borderImage?: MaybeReadAtom<string>;
74
+ readonly borderImageOutset?: MaybeReadAtom<string>;
75
+ readonly borderImageRepeat?: MaybeReadAtom<string>;
76
+ readonly borderImageSlice?: MaybeReadAtom<string>;
77
+ readonly borderImageSource?: MaybeReadAtom<string>;
78
+ readonly borderImageWidth?: MaybeReadAtom<string>;
79
+ readonly borderInline?: MaybeReadAtom<string>;
80
+ readonly borderInlineColor?: MaybeReadAtom<string>;
81
+ readonly borderInlineEnd?: MaybeReadAtom<string>;
82
+ readonly borderInlineEndColor?: MaybeReadAtom<string>;
83
+ readonly borderInlineEndStyle?: MaybeReadAtom<string>;
84
+ readonly borderInlineEndWidth?: MaybeReadAtom<string>;
85
+ readonly borderInlineStart?: MaybeReadAtom<string>;
86
+ readonly borderInlineStartColor?: MaybeReadAtom<string>;
87
+ readonly borderInlineStartStyle?: MaybeReadAtom<string>;
88
+ readonly borderInlineStartWidth?: MaybeReadAtom<string>;
89
+ readonly borderInlineStyle?: MaybeReadAtom<string>;
90
+ readonly borderInlineWidth?: MaybeReadAtom<string>;
91
+ readonly borderLeft?: MaybeReadAtom<string>;
92
+ readonly borderLeftColor?: MaybeReadAtom<string>;
93
+ readonly borderLeftStyle?: MaybeReadAtom<string>;
94
+ readonly borderLeftWidth?: MaybeReadAtom<string>;
95
+ readonly borderRadius?: MaybeReadAtom<string>;
96
+ readonly borderRight?: MaybeReadAtom<string>;
97
+ readonly borderRightColor?: MaybeReadAtom<string>;
98
+ readonly borderRightStyle?: MaybeReadAtom<string>;
99
+ readonly borderRightWidth?: MaybeReadAtom<string>;
100
+ readonly borderSpacing?: MaybeReadAtom<string>;
101
+ readonly borderStartEndRadius?: MaybeReadAtom<string>;
102
+ readonly borderStartStartRadius?: MaybeReadAtom<string>;
103
+ readonly borderStyle?: MaybeReadAtom<string>;
104
+ readonly borderTop?: MaybeReadAtom<string>;
105
+ readonly borderTopColor?: MaybeReadAtom<string>;
106
+ readonly borderTopLeftRadius?: MaybeReadAtom<string>;
107
+ readonly borderTopRightRadius?: MaybeReadAtom<string>;
108
+ readonly borderTopStyle?: MaybeReadAtom<string>;
109
+ readonly borderTopWidth?: MaybeReadAtom<string>;
110
+ readonly borderWidth?: MaybeReadAtom<string>;
111
+ readonly bottom?: MaybeReadAtom<string>;
112
+ readonly boxDecorationBreak?: MaybeReadAtom<string>;
113
+ readonly boxShadow?: MaybeReadAtom<string>;
114
+ readonly boxSizing?: MaybeReadAtom<string>;
115
+ readonly breakAfter?: MaybeReadAtom<string>;
116
+ readonly breakBefore?: MaybeReadAtom<string>;
117
+ readonly breakInside?: MaybeReadAtom<string>;
118
+ readonly captionSide?: MaybeReadAtom<string>;
119
+ readonly caretColor?: MaybeReadAtom<string>;
120
+ readonly clear?: MaybeReadAtom<string>;
121
+ readonly clipPath?: MaybeReadAtom<string>;
122
+ readonly clipRule?: MaybeReadAtom<string>;
123
+ readonly color?: MaybeReadAtom<string>;
124
+ readonly colorInterpolation?: MaybeReadAtom<string>;
125
+ readonly colorInterpolationFilters?: MaybeReadAtom<string>;
126
+ readonly colorScheme?: MaybeReadAtom<string>;
127
+ readonly columnCount?: MaybeReadAtom<string>;
128
+ readonly columnFill?: MaybeReadAtom<string>;
129
+ readonly columnGap?: MaybeReadAtom<string>;
130
+ readonly columnRule?: MaybeReadAtom<string>;
131
+ readonly columnRuleColor?: MaybeReadAtom<string>;
132
+ readonly columnRuleStyle?: MaybeReadAtom<string>;
133
+ readonly columnRuleWidth?: MaybeReadAtom<string>;
134
+ readonly columnSpan?: MaybeReadAtom<string>;
135
+ readonly columnWidth?: MaybeReadAtom<string>;
136
+ readonly columns?: MaybeReadAtom<string>;
137
+ readonly contain?: MaybeReadAtom<string>;
138
+ readonly containIntrinsicBlockSize?: MaybeReadAtom<string>;
139
+ readonly containIntrinsicHeight?: MaybeReadAtom<string>;
140
+ readonly containIntrinsicInlineSize?: MaybeReadAtom<string>;
141
+ readonly containIntrinsicSize?: MaybeReadAtom<string>;
142
+ readonly containIntrinsicWidth?: MaybeReadAtom<string>;
143
+ readonly container?: MaybeReadAtom<string>;
144
+ readonly containerName?: MaybeReadAtom<string>;
145
+ readonly containerType?: MaybeReadAtom<string>;
146
+ readonly content?: MaybeReadAtom<string>;
147
+ readonly contentVisibility?: MaybeReadAtom<string>;
148
+ readonly counterIncrement?: MaybeReadAtom<string>;
149
+ readonly counterReset?: MaybeReadAtom<string>;
150
+ readonly counterSet?: MaybeReadAtom<string>;
151
+ readonly cursor?: MaybeReadAtom<string>;
152
+ readonly cx?: MaybeReadAtom<string>;
153
+ readonly cy?: MaybeReadAtom<string>;
154
+ readonly d?: MaybeReadAtom<string>;
155
+ readonly direction?: MaybeReadAtom<string>;
156
+ readonly display?: MaybeReadAtom<string>;
157
+ readonly dominantBaseline?: MaybeReadAtom<string>;
158
+ readonly dynamicRangeLimit?: MaybeReadAtom<string>;
159
+ readonly emptyCells?: MaybeReadAtom<string>;
160
+ readonly fieldSizing?: MaybeReadAtom<string>;
161
+ readonly fill?: MaybeReadAtom<string>;
162
+ readonly fillOpacity?: MaybeReadAtom<string>;
163
+ readonly fillRule?: MaybeReadAtom<string>;
164
+ readonly filter?: MaybeReadAtom<string>;
165
+ readonly flex?: MaybeReadAtom<string>;
166
+ readonly flexBasis?: MaybeReadAtom<string>;
167
+ readonly flexDirection?: MaybeReadAtom<string>;
168
+ readonly flexFlow?: MaybeReadAtom<string>;
169
+ readonly flexGrow?: MaybeReadAtom<string>;
170
+ readonly flexShrink?: MaybeReadAtom<string>;
171
+ readonly flexWrap?: MaybeReadAtom<string>;
172
+ readonly float?: MaybeReadAtom<string>;
173
+ readonly floodColor?: MaybeReadAtom<string>;
174
+ readonly floodOpacity?: MaybeReadAtom<string>;
175
+ readonly font?: MaybeReadAtom<string>;
176
+ readonly fontFamily?: MaybeReadAtom<string>;
177
+ readonly fontFeatureSettings?: MaybeReadAtom<string>;
178
+ readonly fontKerning?: MaybeReadAtom<string>;
179
+ readonly fontLanguageOverride?: MaybeReadAtom<string>;
180
+ readonly fontOpticalSizing?: MaybeReadAtom<string>;
181
+ readonly fontPalette?: MaybeReadAtom<string>;
182
+ readonly fontSize?: MaybeReadAtom<string>;
183
+ readonly fontSizeAdjust?: MaybeReadAtom<string>;
184
+ readonly fontStyle?: MaybeReadAtom<string>;
185
+ readonly fontSynthesis?: MaybeReadAtom<string>;
186
+ readonly fontSynthesisSmallCaps?: MaybeReadAtom<string>;
187
+ readonly fontSynthesisStyle?: MaybeReadAtom<string>;
188
+ readonly fontSynthesisWeight?: MaybeReadAtom<string>;
189
+ readonly fontVariant?: MaybeReadAtom<string>;
190
+ readonly fontVariantAlternates?: MaybeReadAtom<string>;
191
+ readonly fontVariantCaps?: MaybeReadAtom<string>;
192
+ readonly fontVariantEastAsian?: MaybeReadAtom<string>;
193
+ readonly fontVariantEmoji?: MaybeReadAtom<string>;
194
+ readonly fontVariantLigatures?: MaybeReadAtom<string>;
195
+ readonly fontVariantNumeric?: MaybeReadAtom<string>;
196
+ readonly fontVariantPosition?: MaybeReadAtom<string>;
197
+ readonly fontVariationSettings?: MaybeReadAtom<string>;
198
+ readonly fontWeight?: MaybeReadAtom<string>;
199
+ readonly forcedColorAdjust?: MaybeReadAtom<string>;
200
+ readonly gap?: MaybeReadAtom<string>;
201
+ readonly grid?: MaybeReadAtom<string>;
202
+ readonly gridArea?: MaybeReadAtom<string>;
203
+ readonly gridAutoColumns?: MaybeReadAtom<string>;
204
+ readonly gridAutoFlow?: MaybeReadAtom<string>;
205
+ readonly gridAutoRows?: MaybeReadAtom<string>;
206
+ readonly gridColumn?: MaybeReadAtom<string>;
207
+ readonly gridColumnEnd?: MaybeReadAtom<string>;
208
+ readonly gridColumnStart?: MaybeReadAtom<string>;
209
+ readonly gridRow?: MaybeReadAtom<string>;
210
+ readonly gridRowEnd?: MaybeReadAtom<string>;
211
+ readonly gridRowStart?: MaybeReadAtom<string>;
212
+ readonly gridTemplate?: MaybeReadAtom<string>;
213
+ readonly gridTemplateAreas?: MaybeReadAtom<string>;
214
+ readonly gridTemplateColumns?: MaybeReadAtom<string>;
215
+ readonly gridTemplateRows?: MaybeReadAtom<string>;
216
+ readonly height?: MaybeReadAtom<string>;
217
+ readonly hyphenateCharacter?: MaybeReadAtom<string>;
218
+ readonly hyphenateLimitChars?: MaybeReadAtom<string>;
219
+ readonly hyphens?: MaybeReadAtom<string>;
220
+ readonly imageRendering?: MaybeReadAtom<string>;
221
+ readonly inlineSize?: MaybeReadAtom<string>;
222
+ readonly inset?: MaybeReadAtom<string>;
223
+ readonly insetBlock?: MaybeReadAtom<string>;
224
+ readonly insetBlockEnd?: MaybeReadAtom<string>;
225
+ readonly insetBlockStart?: MaybeReadAtom<string>;
226
+ readonly insetInline?: MaybeReadAtom<string>;
227
+ readonly insetInlineEnd?: MaybeReadAtom<string>;
228
+ readonly insetInlineStart?: MaybeReadAtom<string>;
229
+ readonly isolation?: MaybeReadAtom<string>;
230
+ readonly justifyContent?: MaybeReadAtom<string>;
231
+ readonly justifyItems?: MaybeReadAtom<string>;
232
+ readonly justifySelf?: MaybeReadAtom<string>;
233
+ readonly left?: MaybeReadAtom<string>;
234
+ readonly letterSpacing?: MaybeReadAtom<string>;
235
+ readonly lightingColor?: MaybeReadAtom<string>;
236
+ readonly lineBreak?: MaybeReadAtom<string>;
237
+ readonly lineHeight?: MaybeReadAtom<string>;
238
+ readonly listStyle?: MaybeReadAtom<string>;
239
+ readonly listStyleImage?: MaybeReadAtom<string>;
240
+ readonly listStylePosition?: MaybeReadAtom<string>;
241
+ readonly listStyleType?: MaybeReadAtom<string>;
242
+ readonly margin?: MaybeReadAtom<string>;
243
+ readonly marginBlock?: MaybeReadAtom<string>;
244
+ readonly marginBlockEnd?: MaybeReadAtom<string>;
245
+ readonly marginBlockStart?: MaybeReadAtom<string>;
246
+ readonly marginBottom?: MaybeReadAtom<string>;
247
+ readonly marginInline?: MaybeReadAtom<string>;
248
+ readonly marginInlineEnd?: MaybeReadAtom<string>;
249
+ readonly marginInlineStart?: MaybeReadAtom<string>;
250
+ readonly marginLeft?: MaybeReadAtom<string>;
251
+ readonly marginRight?: MaybeReadAtom<string>;
252
+ readonly marginTop?: MaybeReadAtom<string>;
253
+ readonly marker?: MaybeReadAtom<string>;
254
+ readonly markerEnd?: MaybeReadAtom<string>;
255
+ readonly markerMid?: MaybeReadAtom<string>;
256
+ readonly markerStart?: MaybeReadAtom<string>;
257
+ readonly mask?: MaybeReadAtom<string>;
258
+ readonly maskClip?: MaybeReadAtom<string>;
259
+ readonly maskComposite?: MaybeReadAtom<string>;
260
+ readonly maskImage?: MaybeReadAtom<string>;
261
+ readonly maskMode?: MaybeReadAtom<string>;
262
+ readonly maskOrigin?: MaybeReadAtom<string>;
263
+ readonly maskPosition?: MaybeReadAtom<string>;
264
+ readonly maskRepeat?: MaybeReadAtom<string>;
265
+ readonly maskSize?: MaybeReadAtom<string>;
266
+ readonly maskType?: MaybeReadAtom<string>;
267
+ readonly mathDepth?: MaybeReadAtom<string>;
268
+ readonly mathShift?: MaybeReadAtom<string>;
269
+ readonly mathStyle?: MaybeReadAtom<string>;
270
+ readonly maxBlockSize?: MaybeReadAtom<string>;
271
+ readonly maxHeight?: MaybeReadAtom<string>;
272
+ readonly maxInlineSize?: MaybeReadAtom<string>;
273
+ readonly maxWidth?: MaybeReadAtom<string>;
274
+ readonly minBlockSize?: MaybeReadAtom<string>;
275
+ readonly minHeight?: MaybeReadAtom<string>;
276
+ readonly minInlineSize?: MaybeReadAtom<string>;
277
+ readonly minWidth?: MaybeReadAtom<string>;
278
+ readonly mixBlendMode?: MaybeReadAtom<string>;
279
+ readonly objectFit?: MaybeReadAtom<string>;
280
+ readonly objectPosition?: MaybeReadAtom<string>;
281
+ readonly offset?: MaybeReadAtom<string>;
282
+ readonly offsetAnchor?: MaybeReadAtom<string>;
283
+ readonly offsetDistance?: MaybeReadAtom<string>;
284
+ readonly offsetPath?: MaybeReadAtom<string>;
285
+ readonly offsetPosition?: MaybeReadAtom<string>;
286
+ readonly offsetRotate?: MaybeReadAtom<string>;
287
+ readonly opacity?: MaybeReadAtom<string>;
288
+ readonly order?: MaybeReadAtom<string>;
289
+ readonly orphans?: MaybeReadAtom<string>;
290
+ readonly outline?: MaybeReadAtom<string>;
291
+ readonly outlineColor?: MaybeReadAtom<string>;
292
+ readonly outlineOffset?: MaybeReadAtom<string>;
293
+ readonly outlineStyle?: MaybeReadAtom<string>;
294
+ readonly outlineWidth?: MaybeReadAtom<string>;
295
+ readonly overflow?: MaybeReadAtom<string>;
296
+ readonly overflowAnchor?: MaybeReadAtom<string>;
297
+ readonly overflowBlock?: MaybeReadAtom<string>;
298
+ readonly overflowClipMargin?: MaybeReadAtom<string>;
299
+ readonly overflowInline?: MaybeReadAtom<string>;
300
+ readonly overflowWrap?: MaybeReadAtom<string>;
301
+ readonly overflowX?: MaybeReadAtom<string>;
302
+ readonly overflowY?: MaybeReadAtom<string>;
303
+ readonly overscrollBehavior?: MaybeReadAtom<string>;
304
+ readonly overscrollBehaviorBlock?: MaybeReadAtom<string>;
305
+ readonly overscrollBehaviorInline?: MaybeReadAtom<string>;
306
+ readonly overscrollBehaviorX?: MaybeReadAtom<string>;
307
+ readonly overscrollBehaviorY?: MaybeReadAtom<string>;
308
+ readonly padding?: MaybeReadAtom<string>;
309
+ readonly paddingBlock?: MaybeReadAtom<string>;
310
+ readonly paddingBlockEnd?: MaybeReadAtom<string>;
311
+ readonly paddingBlockStart?: MaybeReadAtom<string>;
312
+ readonly paddingBottom?: MaybeReadAtom<string>;
313
+ readonly paddingInline?: MaybeReadAtom<string>;
314
+ readonly paddingInlineEnd?: MaybeReadAtom<string>;
315
+ readonly paddingInlineStart?: MaybeReadAtom<string>;
316
+ readonly paddingLeft?: MaybeReadAtom<string>;
317
+ readonly paddingRight?: MaybeReadAtom<string>;
318
+ readonly paddingTop?: MaybeReadAtom<string>;
319
+ readonly page?: MaybeReadAtom<string>;
320
+ readonly paintOrder?: MaybeReadAtom<string>;
321
+ readonly perspective?: MaybeReadAtom<string>;
322
+ readonly perspectiveOrigin?: MaybeReadAtom<string>;
323
+ readonly placeContent?: MaybeReadAtom<string>;
324
+ readonly placeItems?: MaybeReadAtom<string>;
325
+ readonly placeSelf?: MaybeReadAtom<string>;
326
+ readonly pointerEvents?: MaybeReadAtom<string>;
327
+ readonly position?: MaybeReadAtom<string>;
328
+ readonly positionTry?: MaybeReadAtom<string>;
329
+ readonly positionTryFallbacks?: MaybeReadAtom<string>;
330
+ readonly positionTryOrder?: MaybeReadAtom<string>;
331
+ readonly positionVisibility?: MaybeReadAtom<string>;
332
+ readonly printColorAdjust?: MaybeReadAtom<string>;
333
+ readonly quotes?: MaybeReadAtom<string>;
334
+ readonly r?: MaybeReadAtom<string>;
335
+ readonly resize?: MaybeReadAtom<string>;
336
+ readonly right?: MaybeReadAtom<string>;
337
+ readonly rotate?: MaybeReadAtom<string>;
338
+ readonly rowGap?: MaybeReadAtom<string>;
339
+ readonly rubyAlign?: MaybeReadAtom<string>;
340
+ readonly rubyPosition?: MaybeReadAtom<string>;
341
+ readonly rx?: MaybeReadAtom<string>;
342
+ readonly ry?: MaybeReadAtom<string>;
343
+ readonly scale?: MaybeReadAtom<string>;
344
+ readonly scrollBehavior?: MaybeReadAtom<string>;
345
+ readonly scrollMargin?: MaybeReadAtom<string>;
346
+ readonly scrollMarginBlock?: MaybeReadAtom<string>;
347
+ readonly scrollMarginBlockEnd?: MaybeReadAtom<string>;
348
+ readonly scrollMarginBlockStart?: MaybeReadAtom<string>;
349
+ readonly scrollMarginBottom?: MaybeReadAtom<string>;
350
+ readonly scrollMarginInline?: MaybeReadAtom<string>;
351
+ readonly scrollMarginInlineEnd?: MaybeReadAtom<string>;
352
+ readonly scrollMarginInlineStart?: MaybeReadAtom<string>;
353
+ readonly scrollMarginLeft?: MaybeReadAtom<string>;
354
+ readonly scrollMarginRight?: MaybeReadAtom<string>;
355
+ readonly scrollMarginTop?: MaybeReadAtom<string>;
356
+ readonly scrollPadding?: MaybeReadAtom<string>;
357
+ readonly scrollPaddingBlock?: MaybeReadAtom<string>;
358
+ readonly scrollPaddingBlockEnd?: MaybeReadAtom<string>;
359
+ readonly scrollPaddingBlockStart?: MaybeReadAtom<string>;
360
+ readonly scrollPaddingBottom?: MaybeReadAtom<string>;
361
+ readonly scrollPaddingInline?: MaybeReadAtom<string>;
362
+ readonly scrollPaddingInlineEnd?: MaybeReadAtom<string>;
363
+ readonly scrollPaddingInlineStart?: MaybeReadAtom<string>;
364
+ readonly scrollPaddingLeft?: MaybeReadAtom<string>;
365
+ readonly scrollPaddingRight?: MaybeReadAtom<string>;
366
+ readonly scrollPaddingTop?: MaybeReadAtom<string>;
367
+ readonly scrollSnapAlign?: MaybeReadAtom<string>;
368
+ readonly scrollSnapStop?: MaybeReadAtom<string>;
369
+ readonly scrollSnapType?: MaybeReadAtom<string>;
370
+ readonly scrollTimeline?: MaybeReadAtom<string>;
371
+ readonly scrollTimelineAxis?: MaybeReadAtom<string>;
372
+ readonly scrollTimelineName?: MaybeReadAtom<string>;
373
+ readonly scrollbarColor?: MaybeReadAtom<string>;
374
+ readonly scrollbarGutter?: MaybeReadAtom<string>;
375
+ readonly scrollbarWidth?: MaybeReadAtom<string>;
376
+ readonly shapeImageThreshold?: MaybeReadAtom<string>;
377
+ readonly shapeMargin?: MaybeReadAtom<string>;
378
+ readonly shapeOutside?: MaybeReadAtom<string>;
379
+ readonly shapeRendering?: MaybeReadAtom<string>;
380
+ readonly stopColor?: MaybeReadAtom<string>;
381
+ readonly stopOpacity?: MaybeReadAtom<string>;
382
+ readonly stroke?: MaybeReadAtom<string>;
383
+ readonly strokeDasharray?: MaybeReadAtom<string>;
384
+ readonly strokeDashoffset?: MaybeReadAtom<string>;
385
+ readonly strokeLinecap?: MaybeReadAtom<string>;
386
+ readonly strokeLinejoin?: MaybeReadAtom<string>;
387
+ readonly strokeMiterlimit?: MaybeReadAtom<string>;
388
+ readonly strokeOpacity?: MaybeReadAtom<string>;
389
+ readonly strokeWidth?: MaybeReadAtom<string>;
390
+ readonly tabSize?: MaybeReadAtom<string>;
391
+ readonly tableLayout?: MaybeReadAtom<string>;
392
+ readonly textAlign?: MaybeReadAtom<string>;
393
+ readonly textAlignLast?: MaybeReadAtom<string>;
394
+ readonly textAnchor?: MaybeReadAtom<string>;
395
+ readonly textAutospace?: MaybeReadAtom<string>;
396
+ readonly textBox?: MaybeReadAtom<string>;
397
+ readonly textBoxEdge?: MaybeReadAtom<string>;
398
+ readonly textBoxTrim?: MaybeReadAtom<string>;
399
+ readonly textCombineUpright?: MaybeReadAtom<string>;
400
+ readonly textDecoration?: MaybeReadAtom<string>;
401
+ readonly textDecorationColor?: MaybeReadAtom<string>;
402
+ readonly textDecorationLine?: MaybeReadAtom<string>;
403
+ readonly textDecorationSkipInk?: MaybeReadAtom<string>;
404
+ readonly textDecorationStyle?: MaybeReadAtom<string>;
405
+ readonly textDecorationThickness?: MaybeReadAtom<string>;
406
+ readonly textEmphasis?: MaybeReadAtom<string>;
407
+ readonly textEmphasisColor?: MaybeReadAtom<string>;
408
+ readonly textEmphasisPosition?: MaybeReadAtom<string>;
409
+ readonly textEmphasisStyle?: MaybeReadAtom<string>;
410
+ readonly textIndent?: MaybeReadAtom<string>;
411
+ readonly textJustify?: MaybeReadAtom<string>;
412
+ readonly textOrientation?: MaybeReadAtom<string>;
413
+ readonly textOverflow?: MaybeReadAtom<string>;
414
+ readonly textRendering?: MaybeReadAtom<string>;
415
+ readonly textShadow?: MaybeReadAtom<string>;
416
+ readonly textTransform?: MaybeReadAtom<string>;
417
+ readonly textUnderlineOffset?: MaybeReadAtom<string>;
418
+ readonly textUnderlinePosition?: MaybeReadAtom<string>;
419
+ readonly textWrap?: MaybeReadAtom<string>;
420
+ readonly textWrapMode?: MaybeReadAtom<string>;
421
+ readonly textWrapStyle?: MaybeReadAtom<string>;
422
+ readonly timelineScope?: MaybeReadAtom<string>;
423
+ readonly top?: MaybeReadAtom<string>;
424
+ readonly touchAction?: MaybeReadAtom<string>;
425
+ readonly transform?: MaybeReadAtom<string>;
426
+ readonly transformBox?: MaybeReadAtom<string>;
427
+ readonly transformOrigin?: MaybeReadAtom<string>;
428
+ readonly transformStyle?: MaybeReadAtom<string>;
429
+ readonly transition?: MaybeReadAtom<string>;
430
+ readonly transitionBehavior?: MaybeReadAtom<string>;
431
+ readonly transitionDelay?: MaybeReadAtom<string>;
432
+ readonly transitionDuration?: MaybeReadAtom<string>;
433
+ readonly transitionProperty?: MaybeReadAtom<string>;
434
+ readonly transitionTimingFunction?: MaybeReadAtom<string>;
435
+ readonly translate?: MaybeReadAtom<string>;
436
+ readonly unicodeBidi?: MaybeReadAtom<string>;
437
+ readonly userSelect?: MaybeReadAtom<string>;
438
+ readonly vectorEffect?: MaybeReadAtom<string>;
439
+ readonly verticalAlign?: MaybeReadAtom<string>;
440
+ readonly viewTimeline?: MaybeReadAtom<string>;
441
+ readonly viewTimelineAxis?: MaybeReadAtom<string>;
442
+ readonly viewTimelineInset?: MaybeReadAtom<string>;
443
+ readonly viewTimelineName?: MaybeReadAtom<string>;
444
+ readonly viewTransitionClass?: MaybeReadAtom<string>;
445
+ readonly viewTransitionName?: MaybeReadAtom<string>;
446
+ readonly visibility?: MaybeReadAtom<string>;
447
+ readonly webkitLineClamp?: MaybeReadAtom<string>;
448
+ readonly webkitTextFillColor?: MaybeReadAtom<string>;
449
+ readonly webkitTextStroke?: MaybeReadAtom<string>;
450
+ readonly webkitTextStrokeColor?: MaybeReadAtom<string>;
451
+ readonly webkitTextStrokeWidth?: MaybeReadAtom<string>;
452
+ readonly whiteSpace?: MaybeReadAtom<string>;
453
+ readonly whiteSpaceCollapse?: MaybeReadAtom<string>;
454
+ readonly widows?: MaybeReadAtom<string>;
455
+ readonly width?: MaybeReadAtom<string>;
456
+ readonly willChange?: MaybeReadAtom<string>;
457
+ readonly wordBreak?: MaybeReadAtom<string>;
458
+ readonly wordSpacing?: MaybeReadAtom<string>;
459
+ readonly writingMode?: MaybeReadAtom<string>;
460
+ readonly x?: MaybeReadAtom<string>;
461
+ readonly y?: MaybeReadAtom<string>;
462
+ readonly zIndex?: MaybeReadAtom<string>;
463
+ readonly zoom?: MaybeReadAtom<string>;
464
+ readonly anchorName?: MaybeReadAtom<string>;
465
+ readonly positionAnchor?: MaybeReadAtom<string>;
466
+ readonly positionArea?: MaybeReadAtom<string>;
467
467
  }
468
468
  interface ARIAProps {
469
- readonly ariaActiveDescendantElement?: MaybeReadonlyAtom<Element | null>;
470
- readonly ariaAtomic?: MaybeReadonlyAtom<string | null>;
471
- readonly ariaAutoComplete?: MaybeReadonlyAtom<string | null>;
472
- readonly ariaBrailleLabel?: MaybeReadonlyAtom<string | null>;
473
- readonly ariaBrailleRoleDescription?: MaybeReadonlyAtom<string | null>;
474
- readonly ariaBusy?: MaybeReadonlyAtom<string | null>;
475
- readonly ariaChecked?: MaybeReadonlyAtom<string | null>;
476
- readonly ariaColCount?: MaybeReadonlyAtom<string | null>;
477
- readonly ariaColIndex?: MaybeReadonlyAtom<string | null>;
478
- readonly ariaColIndexText?: MaybeReadonlyAtom<string | null>;
479
- readonly ariaColSpan?: MaybeReadonlyAtom<string | null>;
480
- readonly ariaControlsElements?: MaybeReadonlyAtom<readonly Element[] | null>;
481
- readonly ariaCurrent?: MaybeReadonlyAtom<string | null>;
482
- readonly ariaDescribedByElements?: MaybeReadonlyAtom<readonly Element[] | null>;
483
- readonly ariaDescription?: MaybeReadonlyAtom<string | null>;
484
- readonly ariaDetailsElements?: MaybeReadonlyAtom<readonly Element[] | null>;
485
- readonly ariaDisabled?: MaybeReadonlyAtom<string | null>;
486
- readonly ariaErrorMessageElements?: MaybeReadonlyAtom<readonly Element[] | null>;
487
- readonly ariaExpanded?: MaybeReadonlyAtom<string | null>;
488
- readonly ariaFlowToElements?: MaybeReadonlyAtom<readonly Element[] | null>;
489
- readonly ariaHasPopup?: MaybeReadonlyAtom<string | null>;
490
- readonly ariaHidden?: MaybeReadonlyAtom<string | null>;
491
- readonly ariaInvalid?: MaybeReadonlyAtom<string | null>;
492
- readonly ariaKeyShortcuts?: MaybeReadonlyAtom<string | null>;
493
- readonly ariaLabel?: MaybeReadonlyAtom<string | null>;
494
- readonly ariaLabelledByElements?: MaybeReadonlyAtom<readonly Element[] | null>;
495
- readonly ariaLevel?: MaybeReadonlyAtom<string | null>;
496
- readonly ariaLive?: MaybeReadonlyAtom<string | null>;
497
- readonly ariaModal?: MaybeReadonlyAtom<string | null>;
498
- readonly ariaMultiLine?: MaybeReadonlyAtom<string | null>;
499
- readonly ariaMultiSelectable?: MaybeReadonlyAtom<string | null>;
500
- readonly ariaOrientation?: MaybeReadonlyAtom<string | null>;
501
- readonly ariaOwnsElements?: MaybeReadonlyAtom<readonly Element[] | null>;
502
- readonly ariaPlaceholder?: MaybeReadonlyAtom<string | null>;
503
- readonly ariaPosInSet?: MaybeReadonlyAtom<string | null>;
504
- readonly ariaPressed?: MaybeReadonlyAtom<string | null>;
505
- readonly ariaReadOnly?: MaybeReadonlyAtom<string | null>;
506
- readonly ariaRelevant?: MaybeReadonlyAtom<string | null>;
507
- readonly ariaRequired?: MaybeReadonlyAtom<string | null>;
508
- readonly ariaRoleDescription?: MaybeReadonlyAtom<string | null>;
509
- readonly ariaRowCount?: MaybeReadonlyAtom<string | null>;
510
- readonly ariaRowIndex?: MaybeReadonlyAtom<string | null>;
511
- readonly ariaRowIndexText?: MaybeReadonlyAtom<string | null>;
512
- readonly ariaRowSpan?: MaybeReadonlyAtom<string | null>;
513
- readonly ariaSelected?: MaybeReadonlyAtom<string | null>;
514
- readonly ariaSetSize?: MaybeReadonlyAtom<string | null>;
515
- readonly ariaSort?: MaybeReadonlyAtom<string | null>;
516
- readonly ariaValueMax?: MaybeReadonlyAtom<string | null>;
517
- readonly ariaValueMin?: MaybeReadonlyAtom<string | null>;
518
- readonly ariaValueNow?: MaybeReadonlyAtom<string | null>;
519
- readonly ariaValueText?: MaybeReadonlyAtom<string | null>;
520
- readonly role?: MaybeReadonlyAtom<string | null>;
469
+ readonly ariaActiveDescendantElement?: MaybeReadAtom<Element | null>;
470
+ readonly ariaAtomic?: MaybeReadAtom<string | null>;
471
+ readonly ariaAutoComplete?: MaybeReadAtom<string | null>;
472
+ readonly ariaBrailleLabel?: MaybeReadAtom<string | null>;
473
+ readonly ariaBrailleRoleDescription?: MaybeReadAtom<string | null>;
474
+ readonly ariaBusy?: MaybeReadAtom<string | null>;
475
+ readonly ariaChecked?: MaybeReadAtom<string | null>;
476
+ readonly ariaColCount?: MaybeReadAtom<string | null>;
477
+ readonly ariaColIndex?: MaybeReadAtom<string | null>;
478
+ readonly ariaColIndexText?: MaybeReadAtom<string | null>;
479
+ readonly ariaColSpan?: MaybeReadAtom<string | null>;
480
+ readonly ariaControlsElements?: MaybeReadAtom<readonly Element[] | null>;
481
+ readonly ariaCurrent?: MaybeReadAtom<string | null>;
482
+ readonly ariaDescribedByElements?: MaybeReadAtom<readonly Element[] | null>;
483
+ readonly ariaDescription?: MaybeReadAtom<string | null>;
484
+ readonly ariaDetailsElements?: MaybeReadAtom<readonly Element[] | null>;
485
+ readonly ariaDisabled?: MaybeReadAtom<string | null>;
486
+ readonly ariaErrorMessageElements?: MaybeReadAtom<readonly Element[] | null>;
487
+ readonly ariaExpanded?: MaybeReadAtom<string | null>;
488
+ readonly ariaFlowToElements?: MaybeReadAtom<readonly Element[] | null>;
489
+ readonly ariaHasPopup?: MaybeReadAtom<string | null>;
490
+ readonly ariaHidden?: MaybeReadAtom<string | null>;
491
+ readonly ariaInvalid?: MaybeReadAtom<string | null>;
492
+ readonly ariaKeyShortcuts?: MaybeReadAtom<string | null>;
493
+ readonly ariaLabel?: MaybeReadAtom<string | null>;
494
+ readonly ariaLabelledByElements?: MaybeReadAtom<readonly Element[] | null>;
495
+ readonly ariaLevel?: MaybeReadAtom<string | null>;
496
+ readonly ariaLive?: MaybeReadAtom<string | null>;
497
+ readonly ariaModal?: MaybeReadAtom<string | null>;
498
+ readonly ariaMultiLine?: MaybeReadAtom<string | null>;
499
+ readonly ariaMultiSelectable?: MaybeReadAtom<string | null>;
500
+ readonly ariaOrientation?: MaybeReadAtom<string | null>;
501
+ readonly ariaOwnsElements?: MaybeReadAtom<readonly Element[] | null>;
502
+ readonly ariaPlaceholder?: MaybeReadAtom<string | null>;
503
+ readonly ariaPosInSet?: MaybeReadAtom<string | null>;
504
+ readonly ariaPressed?: MaybeReadAtom<string | null>;
505
+ readonly ariaReadOnly?: MaybeReadAtom<string | null>;
506
+ readonly ariaRelevant?: MaybeReadAtom<string | null>;
507
+ readonly ariaRequired?: MaybeReadAtom<string | null>;
508
+ readonly ariaRoleDescription?: MaybeReadAtom<string | null>;
509
+ readonly ariaRowCount?: MaybeReadAtom<string | null>;
510
+ readonly ariaRowIndex?: MaybeReadAtom<string | null>;
511
+ readonly ariaRowIndexText?: MaybeReadAtom<string | null>;
512
+ readonly ariaRowSpan?: MaybeReadAtom<string | null>;
513
+ readonly ariaSelected?: MaybeReadAtom<string | null>;
514
+ readonly ariaSetSize?: MaybeReadAtom<string | null>;
515
+ readonly ariaSort?: MaybeReadAtom<string | null>;
516
+ readonly ariaValueMax?: MaybeReadAtom<string | null>;
517
+ readonly ariaValueMin?: MaybeReadAtom<string | null>;
518
+ readonly ariaValueNow?: MaybeReadAtom<string | null>;
519
+ readonly ariaValueText?: MaybeReadAtom<string | null>;
520
+ readonly role?: MaybeReadAtom<string | null>;
521
521
  }
522
522
  interface HTMLGlobalProps {
523
- readonly translate?: MaybeReadonlyAtom<boolean>;
524
- readonly part?: MaybeReadonlyAtom<string>;
525
- readonly class?: MaybeReadonlyAtom<string>;
526
- readonly accessKey?: MaybeReadonlyAtom<string>;
527
- readonly autocapitalize?: MaybeReadonlyAtom<string>;
528
- readonly autocorrect?: MaybeReadonlyAtom<boolean>;
529
- readonly dir?: MaybeReadonlyAtom<string>;
530
- readonly draggable?: MaybeReadonlyAtom<boolean>;
531
- readonly hidden?: MaybeReadonlyAtom<boolean | "until-found">;
532
- readonly inert?: MaybeReadonlyAtom<boolean>;
533
- readonly lang?: MaybeReadonlyAtom<string>;
534
- readonly popover?: MaybeReadonlyAtom<string | null>;
535
- readonly spellcheck?: MaybeReadonlyAtom<boolean>;
536
- readonly title?: MaybeReadonlyAtom<string>;
537
- readonly writingSuggestions?: MaybeReadonlyAtom<string>;
538
- readonly id?: MaybeReadonlyAtom<string>;
539
- readonly scrollLeft?: MaybeReadonlyAtom<number>;
540
- readonly scrollTop?: MaybeReadonlyAtom<number>;
541
- readonly slot?: MaybeReadonlyAtom<string>;
542
- readonly contentEditable?: MaybeReadonlyAtom<string>;
543
- readonly enterKeyHint?: MaybeReadonlyAtom<string>;
544
- readonly inputMode?: MaybeReadonlyAtom<string>;
545
- readonly autofocus?: MaybeReadonlyAtom<boolean>;
546
- readonly nonce?: MaybeReadonlyAtom<string>;
547
- readonly tabIndex?: MaybeReadonlyAtom<number>;
523
+ readonly translate?: MaybeReadAtom<boolean>;
524
+ readonly part?: MaybeReadAtom<string>;
525
+ readonly class?: MaybeReadAtom<string>;
526
+ readonly accessKey?: MaybeReadAtom<string>;
527
+ readonly autocapitalize?: MaybeReadAtom<string>;
528
+ readonly autocorrect?: MaybeReadAtom<boolean>;
529
+ readonly dir?: MaybeReadAtom<string>;
530
+ readonly draggable?: MaybeReadAtom<boolean>;
531
+ readonly hidden?: MaybeReadAtom<boolean | "until-found">;
532
+ readonly inert?: MaybeReadAtom<boolean>;
533
+ readonly lang?: MaybeReadAtom<string>;
534
+ readonly popover?: MaybeReadAtom<string | null>;
535
+ readonly spellcheck?: MaybeReadAtom<boolean>;
536
+ readonly title?: MaybeReadAtom<string>;
537
+ readonly writingSuggestions?: MaybeReadAtom<string>;
538
+ readonly id?: MaybeReadAtom<string>;
539
+ readonly scrollLeft?: MaybeReadAtom<number>;
540
+ readonly scrollTop?: MaybeReadAtom<number>;
541
+ readonly slot?: MaybeReadAtom<string>;
542
+ readonly contentEditable?: MaybeReadAtom<string>;
543
+ readonly enterKeyHint?: MaybeReadAtom<string>;
544
+ readonly inputMode?: MaybeReadAtom<string>;
545
+ readonly autofocus?: MaybeReadAtom<boolean>;
546
+ readonly nonce?: MaybeReadAtom<string>;
547
+ readonly tabIndex?: MaybeReadAtom<number>;
548
548
  }
549
549
  interface HTMLAnchorElementProps extends HTMLGlobalProps {
550
550
  readonly [S_NODE_TYPE]?: HTMLAnchorElement;
551
551
  readonly children?: JsxChildren;
552
- readonly charset?: MaybeReadonlyAtom<string>;
553
- readonly coords?: MaybeReadonlyAtom<string>;
554
- readonly download?: MaybeReadonlyAtom<string>;
555
- readonly hreflang?: MaybeReadonlyAtom<string>;
556
- readonly name?: MaybeReadonlyAtom<string>;
557
- readonly ping?: MaybeReadonlyAtom<string>;
558
- readonly referrerPolicy?: MaybeReadonlyAtom<string>;
559
- readonly rel?: MaybeReadonlyAtom<string>;
560
- readonly relList?: MaybeReadonlyAtom<string>;
561
- readonly rev?: MaybeReadonlyAtom<string>;
562
- readonly shape?: MaybeReadonlyAtom<string>;
563
- readonly target?: MaybeReadonlyAtom<string>;
564
- readonly text?: MaybeReadonlyAtom<string>;
565
- readonly type?: MaybeReadonlyAtom<string>;
566
- readonly hash?: MaybeReadonlyAtom<string>;
567
- readonly host?: MaybeReadonlyAtom<string>;
568
- readonly hostname?: MaybeReadonlyAtom<string>;
569
- readonly href?: MaybeReadonlyAtom<string>;
570
- readonly password?: MaybeReadonlyAtom<string>;
571
- readonly pathname?: MaybeReadonlyAtom<string>;
572
- readonly port?: MaybeReadonlyAtom<string>;
573
- readonly protocol?: MaybeReadonlyAtom<string>;
574
- readonly search?: MaybeReadonlyAtom<string>;
575
- readonly username?: MaybeReadonlyAtom<string>;
552
+ readonly charset?: MaybeReadAtom<string>;
553
+ readonly coords?: MaybeReadAtom<string>;
554
+ readonly download?: MaybeReadAtom<string>;
555
+ readonly hreflang?: MaybeReadAtom<string>;
556
+ readonly name?: MaybeReadAtom<string>;
557
+ readonly ping?: MaybeReadAtom<string>;
558
+ readonly referrerPolicy?: MaybeReadAtom<string>;
559
+ readonly rel?: MaybeReadAtom<string>;
560
+ readonly relList?: MaybeReadAtom<string>;
561
+ readonly rev?: MaybeReadAtom<string>;
562
+ readonly shape?: MaybeReadAtom<string>;
563
+ readonly target?: MaybeReadAtom<string>;
564
+ readonly text?: MaybeReadAtom<string>;
565
+ readonly type?: MaybeReadAtom<string>;
566
+ readonly hash?: MaybeReadAtom<string>;
567
+ readonly host?: MaybeReadAtom<string>;
568
+ readonly hostname?: MaybeReadAtom<string>;
569
+ readonly href?: MaybeReadAtom<string>;
570
+ readonly password?: MaybeReadAtom<string>;
571
+ readonly pathname?: MaybeReadAtom<string>;
572
+ readonly port?: MaybeReadAtom<string>;
573
+ readonly protocol?: MaybeReadAtom<string>;
574
+ readonly search?: MaybeReadAtom<string>;
575
+ readonly username?: MaybeReadAtom<string>;
576
576
  }
577
577
  interface HTMLAreaElementProps extends HTMLGlobalProps {
578
578
  readonly [S_NODE_TYPE]?: HTMLAreaElement;
579
579
  readonly children?: never;
580
- readonly coords?: MaybeReadonlyAtom<string>;
581
- readonly download?: MaybeReadonlyAtom<string>;
582
- readonly ping?: MaybeReadonlyAtom<string>;
583
- readonly referrerPolicy?: MaybeReadonlyAtom<string>;
584
- readonly rel?: MaybeReadonlyAtom<string>;
585
- readonly relList?: MaybeReadonlyAtom<string>;
586
- readonly shape?: MaybeReadonlyAtom<string>;
587
- readonly target?: MaybeReadonlyAtom<string>;
588
- readonly hash?: MaybeReadonlyAtom<string>;
589
- readonly host?: MaybeReadonlyAtom<string>;
590
- readonly hostname?: MaybeReadonlyAtom<string>;
591
- readonly href?: MaybeReadonlyAtom<string>;
592
- readonly password?: MaybeReadonlyAtom<string>;
593
- readonly pathname?: MaybeReadonlyAtom<string>;
594
- readonly port?: MaybeReadonlyAtom<string>;
595
- readonly protocol?: MaybeReadonlyAtom<string>;
596
- readonly search?: MaybeReadonlyAtom<string>;
597
- readonly username?: MaybeReadonlyAtom<string>;
598
- readonly alt?: MaybeReadonlyAtom<string>;
599
- readonly noHref?: MaybeReadonlyAtom<boolean>;
580
+ readonly coords?: MaybeReadAtom<string>;
581
+ readonly download?: MaybeReadAtom<string>;
582
+ readonly ping?: MaybeReadAtom<string>;
583
+ readonly referrerPolicy?: MaybeReadAtom<string>;
584
+ readonly rel?: MaybeReadAtom<string>;
585
+ readonly relList?: MaybeReadAtom<string>;
586
+ readonly shape?: MaybeReadAtom<string>;
587
+ readonly target?: MaybeReadAtom<string>;
588
+ readonly hash?: MaybeReadAtom<string>;
589
+ readonly host?: MaybeReadAtom<string>;
590
+ readonly hostname?: MaybeReadAtom<string>;
591
+ readonly href?: MaybeReadAtom<string>;
592
+ readonly password?: MaybeReadAtom<string>;
593
+ readonly pathname?: MaybeReadAtom<string>;
594
+ readonly port?: MaybeReadAtom<string>;
595
+ readonly protocol?: MaybeReadAtom<string>;
596
+ readonly search?: MaybeReadAtom<string>;
597
+ readonly username?: MaybeReadAtom<string>;
598
+ readonly alt?: MaybeReadAtom<string>;
599
+ readonly noHref?: MaybeReadAtom<boolean>;
600
600
  }
601
601
  interface HTMLAudioElementProps extends HTMLGlobalProps {
602
602
  readonly [S_NODE_TYPE]?: HTMLAudioElement;
603
603
  readonly children?: JsxChildren;
604
- readonly autoplay?: MaybeReadonlyAtom<boolean>;
605
- readonly controls?: MaybeReadonlyAtom<boolean>;
606
- readonly crossOrigin?: MaybeReadonlyAtom<string | null>;
607
- readonly currentTime?: MaybeReadonlyAtom<number>;
608
- readonly defaultMuted?: MaybeReadonlyAtom<boolean>;
609
- readonly defaultPlaybackRate?: MaybeReadonlyAtom<number>;
610
- readonly disableRemotePlayback?: MaybeReadonlyAtom<boolean>;
611
- readonly loop?: MaybeReadonlyAtom<boolean>;
612
- readonly muted?: MaybeReadonlyAtom<boolean>;
613
- readonly playbackRate?: MaybeReadonlyAtom<number>;
614
- readonly preload?: MaybeReadonlyAtom<"" | "none" | "metadata" | "auto">;
615
- readonly preservesPitch?: MaybeReadonlyAtom<boolean>;
616
- readonly src?: MaybeReadonlyAtom<string>;
617
- readonly srcObject?: MaybeReadonlyAtom<MediaProvider | null>;
618
- readonly volume?: MaybeReadonlyAtom<number>;
604
+ readonly autoplay?: MaybeReadAtom<boolean>;
605
+ readonly controls?: MaybeReadAtom<boolean>;
606
+ readonly crossOrigin?: MaybeReadAtom<string | null>;
607
+ readonly currentTime?: MaybeReadAtom<number>;
608
+ readonly defaultMuted?: MaybeReadAtom<boolean>;
609
+ readonly defaultPlaybackRate?: MaybeReadAtom<number>;
610
+ readonly disableRemotePlayback?: MaybeReadAtom<boolean>;
611
+ readonly loop?: MaybeReadAtom<boolean>;
612
+ readonly muted?: MaybeReadAtom<boolean>;
613
+ readonly playbackRate?: MaybeReadAtom<number>;
614
+ readonly preload?: MaybeReadAtom<"" | "none" | "metadata" | "auto">;
615
+ readonly preservesPitch?: MaybeReadAtom<boolean>;
616
+ readonly src?: MaybeReadAtom<string>;
617
+ readonly srcObject?: MaybeReadAtom<MediaProvider | null>;
618
+ readonly volume?: MaybeReadAtom<number>;
619
619
  }
620
620
  interface HTMLBaseElementProps extends HTMLGlobalProps {
621
621
  readonly [S_NODE_TYPE]?: HTMLBaseElement;
622
622
  readonly children?: never;
623
- readonly target?: MaybeReadonlyAtom<string>;
624
- readonly href?: MaybeReadonlyAtom<string>;
623
+ readonly target?: MaybeReadAtom<string>;
624
+ readonly href?: MaybeReadAtom<string>;
625
625
  }
626
626
  interface HTMLElementProps extends HTMLGlobalProps {
627
627
  readonly [S_NODE_TYPE]?: HTMLElement;
@@ -630,55 +630,55 @@ interface HTMLElementProps extends HTMLGlobalProps {
630
630
  interface HTMLQuoteElementProps extends HTMLGlobalProps {
631
631
  readonly [S_NODE_TYPE]?: HTMLQuoteElement;
632
632
  readonly children?: JsxChildren;
633
- readonly cite?: MaybeReadonlyAtom<string>;
633
+ readonly cite?: MaybeReadAtom<string>;
634
634
  }
635
635
  interface HTMLBRElementProps extends HTMLGlobalProps {
636
636
  readonly [S_NODE_TYPE]?: HTMLBRElement;
637
637
  readonly children?: never;
638
- readonly clear?: MaybeReadonlyAtom<string>;
638
+ readonly clear?: MaybeReadAtom<string>;
639
639
  }
640
640
  interface HTMLButtonElementProps extends HTMLGlobalProps {
641
641
  readonly [S_NODE_TYPE]?: HTMLButtonElement;
642
642
  readonly children?: JsxChildren;
643
- readonly name?: MaybeReadonlyAtom<string>;
644
- readonly type?: MaybeReadonlyAtom<"submit" | "reset" | "button">;
645
- readonly command?: MaybeReadonlyAtom<string>;
646
- readonly commandForElement?: MaybeReadonlyAtom<Element | null>;
647
- readonly disabled?: MaybeReadonlyAtom<boolean>;
648
- readonly formAction?: MaybeReadonlyAtom<string>;
649
- readonly formEnctype?: MaybeReadonlyAtom<string>;
650
- readonly formMethod?: MaybeReadonlyAtom<string>;
651
- readonly formNoValidate?: MaybeReadonlyAtom<boolean>;
652
- readonly formTarget?: MaybeReadonlyAtom<string>;
653
- readonly value?: MaybeReadonlyAtom<string>;
654
- readonly popoverTargetAction?: MaybeReadonlyAtom<string>;
655
- readonly popoverTargetElement?: MaybeReadonlyAtom<Element | null>;
643
+ readonly name?: MaybeReadAtom<string>;
644
+ readonly type?: MaybeReadAtom<"submit" | "reset" | "button">;
645
+ readonly command?: MaybeReadAtom<string>;
646
+ readonly commandForElement?: MaybeReadAtom<Element | null>;
647
+ readonly disabled?: MaybeReadAtom<boolean>;
648
+ readonly formAction?: MaybeReadAtom<string>;
649
+ readonly formEnctype?: MaybeReadAtom<string>;
650
+ readonly formMethod?: MaybeReadAtom<string>;
651
+ readonly formNoValidate?: MaybeReadAtom<boolean>;
652
+ readonly formTarget?: MaybeReadAtom<string>;
653
+ readonly value?: MaybeReadAtom<string>;
654
+ readonly popoverTargetAction?: MaybeReadAtom<string>;
655
+ readonly popoverTargetElement?: MaybeReadAtom<Element | null>;
656
656
  }
657
657
  interface HTMLCanvasElementProps extends HTMLGlobalProps {
658
658
  readonly [S_NODE_TYPE]?: HTMLCanvasElement;
659
659
  readonly children?: JsxChildren;
660
- readonly height?: MaybeReadonlyAtom<number>;
661
- readonly width?: MaybeReadonlyAtom<number>;
660
+ readonly height?: MaybeReadAtom<number>;
661
+ readonly width?: MaybeReadAtom<number>;
662
662
  }
663
663
  interface HTMLTableCaptionElementProps extends HTMLGlobalProps {
664
664
  readonly [S_NODE_TYPE]?: HTMLTableCaptionElement;
665
665
  readonly children?: JsxChildren;
666
- readonly align?: MaybeReadonlyAtom<string>;
666
+ readonly align?: MaybeReadAtom<string>;
667
667
  }
668
668
  interface HTMLTableColElementProps extends HTMLGlobalProps {
669
669
  readonly [S_NODE_TYPE]?: HTMLTableColElement;
670
670
  readonly children?: never;
671
- readonly width?: MaybeReadonlyAtom<string>;
672
- readonly align?: MaybeReadonlyAtom<string>;
673
- readonly ch?: MaybeReadonlyAtom<string>;
674
- readonly chOff?: MaybeReadonlyAtom<string>;
675
- readonly span?: MaybeReadonlyAtom<number>;
676
- readonly vAlign?: MaybeReadonlyAtom<string>;
671
+ readonly width?: MaybeReadAtom<string>;
672
+ readonly align?: MaybeReadAtom<string>;
673
+ readonly ch?: MaybeReadAtom<string>;
674
+ readonly chOff?: MaybeReadAtom<string>;
675
+ readonly span?: MaybeReadAtom<number>;
676
+ readonly vAlign?: MaybeReadAtom<string>;
677
677
  }
678
678
  interface HTMLDataElementProps extends HTMLGlobalProps {
679
679
  readonly [S_NODE_TYPE]?: HTMLDataElement;
680
680
  readonly children?: JsxChildren;
681
- readonly value?: MaybeReadonlyAtom<string>;
681
+ readonly value?: MaybeReadAtom<string>;
682
682
  }
683
683
  interface HTMLDataListElementProps extends HTMLGlobalProps {
684
684
  readonly [S_NODE_TYPE]?: HTMLDataListElement;
@@ -687,260 +687,260 @@ interface HTMLDataListElementProps extends HTMLGlobalProps {
687
687
  interface HTMLModElementProps extends HTMLGlobalProps {
688
688
  readonly [S_NODE_TYPE]?: HTMLModElement;
689
689
  readonly children?: JsxChildren;
690
- readonly cite?: MaybeReadonlyAtom<string>;
691
- readonly dateTime?: MaybeReadonlyAtom<string>;
690
+ readonly cite?: MaybeReadAtom<string>;
691
+ readonly dateTime?: MaybeReadAtom<string>;
692
692
  }
693
693
  interface HTMLDetailsElementProps extends HTMLGlobalProps {
694
694
  readonly [S_NODE_TYPE]?: HTMLDetailsElement;
695
695
  readonly children?: JsxChildren;
696
- readonly name?: MaybeReadonlyAtom<string>;
697
- readonly open?: MaybeReadonlyAtom<boolean>;
696
+ readonly name?: MaybeReadAtom<string>;
697
+ readonly open?: MaybeReadAtom<boolean>;
698
698
  }
699
699
  interface HTMLDialogElementProps extends HTMLGlobalProps {
700
700
  readonly [S_NODE_TYPE]?: HTMLDialogElement;
701
701
  readonly children?: JsxChildren;
702
- readonly open?: MaybeReadonlyAtom<boolean>;
703
- readonly closedBy?: MaybeReadonlyAtom<string>;
704
- readonly returnValue?: MaybeReadonlyAtom<string>;
702
+ readonly open?: MaybeReadAtom<boolean>;
703
+ readonly closedBy?: MaybeReadAtom<string>;
704
+ readonly returnValue?: MaybeReadAtom<string>;
705
705
  }
706
706
  interface HTMLDivElementProps extends HTMLGlobalProps {
707
707
  readonly [S_NODE_TYPE]?: HTMLDivElement;
708
708
  readonly children?: JsxChildren;
709
- readonly align?: MaybeReadonlyAtom<string>;
709
+ readonly align?: MaybeReadAtom<string>;
710
710
  }
711
711
  interface HTMLDListElementProps extends HTMLGlobalProps {
712
712
  readonly [S_NODE_TYPE]?: HTMLDListElement;
713
713
  readonly children?: JsxChildren;
714
- readonly compact?: MaybeReadonlyAtom<boolean>;
714
+ readonly compact?: MaybeReadAtom<boolean>;
715
715
  }
716
716
  interface HTMLEmbedElementProps extends HTMLGlobalProps {
717
717
  readonly [S_NODE_TYPE]?: HTMLEmbedElement;
718
718
  readonly children?: never;
719
- readonly height?: MaybeReadonlyAtom<string>;
720
- readonly width?: MaybeReadonlyAtom<string>;
721
- readonly name?: MaybeReadonlyAtom<string>;
722
- readonly type?: MaybeReadonlyAtom<string>;
723
- readonly src?: MaybeReadonlyAtom<string>;
724
- readonly align?: MaybeReadonlyAtom<string>;
719
+ readonly height?: MaybeReadAtom<string>;
720
+ readonly width?: MaybeReadAtom<string>;
721
+ readonly name?: MaybeReadAtom<string>;
722
+ readonly type?: MaybeReadAtom<string>;
723
+ readonly src?: MaybeReadAtom<string>;
724
+ readonly align?: MaybeReadAtom<string>;
725
725
  }
726
726
  interface HTMLFieldSetElementProps extends HTMLGlobalProps {
727
727
  readonly [S_NODE_TYPE]?: HTMLFieldSetElement;
728
728
  readonly children?: JsxChildren;
729
- readonly name?: MaybeReadonlyAtom<string>;
730
- readonly disabled?: MaybeReadonlyAtom<boolean>;
729
+ readonly name?: MaybeReadAtom<string>;
730
+ readonly disabled?: MaybeReadAtom<boolean>;
731
731
  }
732
732
  interface HTMLFormElementProps extends HTMLGlobalProps {
733
733
  readonly [S_NODE_TYPE]?: HTMLFormElement;
734
734
  readonly children?: JsxChildren;
735
- readonly name?: MaybeReadonlyAtom<string>;
736
- readonly rel?: MaybeReadonlyAtom<string>;
737
- readonly relList?: MaybeReadonlyAtom<string>;
738
- readonly target?: MaybeReadonlyAtom<string>;
739
- readonly acceptCharset?: MaybeReadonlyAtom<string>;
740
- readonly action?: MaybeReadonlyAtom<string>;
741
- readonly autocomplete?: MaybeReadonlyAtom<AutoFillBase>;
742
- readonly encoding?: MaybeReadonlyAtom<string>;
743
- readonly enctype?: MaybeReadonlyAtom<string>;
744
- readonly method?: MaybeReadonlyAtom<string>;
745
- readonly noValidate?: MaybeReadonlyAtom<boolean>;
735
+ readonly name?: MaybeReadAtom<string>;
736
+ readonly rel?: MaybeReadAtom<string>;
737
+ readonly relList?: MaybeReadAtom<string>;
738
+ readonly target?: MaybeReadAtom<string>;
739
+ readonly acceptCharset?: MaybeReadAtom<string>;
740
+ readonly action?: MaybeReadAtom<string>;
741
+ readonly autocomplete?: MaybeReadAtom<AutoFillBase>;
742
+ readonly encoding?: MaybeReadAtom<string>;
743
+ readonly enctype?: MaybeReadAtom<string>;
744
+ readonly method?: MaybeReadAtom<string>;
745
+ readonly noValidate?: MaybeReadAtom<boolean>;
746
746
  }
747
747
  interface HTMLHeadingElementProps extends HTMLGlobalProps {
748
748
  readonly [S_NODE_TYPE]?: HTMLHeadingElement;
749
749
  readonly children?: JsxChildren;
750
- readonly align?: MaybeReadonlyAtom<string>;
750
+ readonly align?: MaybeReadAtom<string>;
751
751
  }
752
752
  interface HTMLHRElementProps extends HTMLGlobalProps {
753
753
  readonly [S_NODE_TYPE]?: HTMLHRElement;
754
754
  readonly children?: never;
755
- readonly color?: MaybeReadonlyAtom<string>;
756
- readonly width?: MaybeReadonlyAtom<string>;
757
- readonly align?: MaybeReadonlyAtom<string>;
758
- readonly noShade?: MaybeReadonlyAtom<boolean>;
759
- readonly size?: MaybeReadonlyAtom<string>;
755
+ readonly color?: MaybeReadAtom<string>;
756
+ readonly width?: MaybeReadAtom<string>;
757
+ readonly align?: MaybeReadAtom<string>;
758
+ readonly noShade?: MaybeReadAtom<boolean>;
759
+ readonly size?: MaybeReadAtom<string>;
760
760
  }
761
761
  interface HTMLIFrameElementProps extends HTMLGlobalProps {
762
762
  readonly [S_NODE_TYPE]?: HTMLIFrameElement;
763
763
  readonly children?: JsxChildren;
764
- readonly height?: MaybeReadonlyAtom<string>;
765
- readonly width?: MaybeReadonlyAtom<string>;
766
- readonly name?: MaybeReadonlyAtom<string>;
767
- readonly referrerPolicy?: MaybeReadonlyAtom<ReferrerPolicy>;
768
- readonly src?: MaybeReadonlyAtom<string>;
769
- readonly align?: MaybeReadonlyAtom<string>;
770
- readonly allow?: MaybeReadonlyAtom<string>;
771
- readonly allowFullscreen?: MaybeReadonlyAtom<boolean>;
772
- readonly frameBorder?: MaybeReadonlyAtom<string>;
773
- readonly loading?: MaybeReadonlyAtom<"eager" | "lazy">;
774
- readonly longDesc?: MaybeReadonlyAtom<string>;
775
- readonly marginHeight?: MaybeReadonlyAtom<string>;
776
- readonly marginWidth?: MaybeReadonlyAtom<string>;
777
- readonly sandbox?: MaybeReadonlyAtom<DOMTokenList>;
778
- readonly scrolling?: MaybeReadonlyAtom<string>;
779
- readonly srcdoc?: MaybeReadonlyAtom<string>;
764
+ readonly height?: MaybeReadAtom<string>;
765
+ readonly width?: MaybeReadAtom<string>;
766
+ readonly name?: MaybeReadAtom<string>;
767
+ readonly referrerPolicy?: MaybeReadAtom<ReferrerPolicy>;
768
+ readonly src?: MaybeReadAtom<string>;
769
+ readonly align?: MaybeReadAtom<string>;
770
+ readonly allow?: MaybeReadAtom<string>;
771
+ readonly allowFullscreen?: MaybeReadAtom<boolean>;
772
+ readonly frameBorder?: MaybeReadAtom<string>;
773
+ readonly loading?: MaybeReadAtom<"eager" | "lazy">;
774
+ readonly longDesc?: MaybeReadAtom<string>;
775
+ readonly marginHeight?: MaybeReadAtom<string>;
776
+ readonly marginWidth?: MaybeReadAtom<string>;
777
+ readonly sandbox?: MaybeReadAtom<DOMTokenList>;
778
+ readonly scrolling?: MaybeReadAtom<string>;
779
+ readonly srcdoc?: MaybeReadAtom<string>;
780
780
  }
781
781
  interface HTMLImageElementProps extends HTMLGlobalProps {
782
782
  readonly [S_NODE_TYPE]?: HTMLImageElement;
783
783
  readonly children?: never;
784
- readonly border?: MaybeReadonlyAtom<string>;
785
- readonly height?: MaybeReadonlyAtom<number>;
786
- readonly width?: MaybeReadonlyAtom<number>;
787
- readonly name?: MaybeReadonlyAtom<string>;
788
- readonly referrerPolicy?: MaybeReadonlyAtom<string>;
789
- readonly alt?: MaybeReadonlyAtom<string>;
790
- readonly crossOrigin?: MaybeReadonlyAtom<string | null>;
791
- readonly src?: MaybeReadonlyAtom<string>;
792
- readonly align?: MaybeReadonlyAtom<string>;
793
- readonly loading?: MaybeReadonlyAtom<"eager" | "lazy">;
794
- readonly longDesc?: MaybeReadonlyAtom<string>;
795
- readonly decoding?: MaybeReadonlyAtom<"auto" | "async" | "sync">;
796
- readonly fetchPriority?: MaybeReadonlyAtom<"auto" | "high" | "low">;
797
- readonly hspace?: MaybeReadonlyAtom<number>;
798
- readonly isMap?: MaybeReadonlyAtom<boolean>;
799
- readonly lowsrc?: MaybeReadonlyAtom<string>;
800
- readonly sizes?: MaybeReadonlyAtom<string>;
801
- readonly srcset?: MaybeReadonlyAtom<string>;
802
- readonly useMap?: MaybeReadonlyAtom<string>;
803
- readonly vspace?: MaybeReadonlyAtom<number>;
784
+ readonly border?: MaybeReadAtom<string>;
785
+ readonly height?: MaybeReadAtom<number>;
786
+ readonly width?: MaybeReadAtom<number>;
787
+ readonly name?: MaybeReadAtom<string>;
788
+ readonly referrerPolicy?: MaybeReadAtom<string>;
789
+ readonly alt?: MaybeReadAtom<string>;
790
+ readonly crossOrigin?: MaybeReadAtom<string | null>;
791
+ readonly src?: MaybeReadAtom<string>;
792
+ readonly align?: MaybeReadAtom<string>;
793
+ readonly loading?: MaybeReadAtom<"eager" | "lazy">;
794
+ readonly longDesc?: MaybeReadAtom<string>;
795
+ readonly decoding?: MaybeReadAtom<"auto" | "async" | "sync">;
796
+ readonly fetchPriority?: MaybeReadAtom<"auto" | "high" | "low">;
797
+ readonly hspace?: MaybeReadAtom<number>;
798
+ readonly isMap?: MaybeReadAtom<boolean>;
799
+ readonly lowsrc?: MaybeReadAtom<string>;
800
+ readonly sizes?: MaybeReadAtom<string>;
801
+ readonly srcset?: MaybeReadAtom<string>;
802
+ readonly useMap?: MaybeReadAtom<string>;
803
+ readonly vspace?: MaybeReadAtom<number>;
804
804
  }
805
805
  interface HTMLInputElementProps extends HTMLGlobalProps {
806
806
  readonly [S_NODE_TYPE]?: HTMLInputElement;
807
807
  readonly children?: never;
808
- readonly height?: MaybeReadonlyAtom<number>;
809
- readonly width?: MaybeReadonlyAtom<number>;
810
- readonly name?: MaybeReadonlyAtom<string>;
811
- readonly type?: MaybeReadonlyAtom<string>;
812
- readonly alt?: MaybeReadonlyAtom<string>;
813
- readonly src?: MaybeReadonlyAtom<string>;
814
- readonly disabled?: MaybeReadonlyAtom<boolean>;
815
- readonly formAction?: MaybeReadonlyAtom<string>;
816
- readonly formEnctype?: MaybeReadonlyAtom<string>;
817
- readonly formMethod?: MaybeReadonlyAtom<string>;
818
- readonly formNoValidate?: MaybeReadonlyAtom<boolean>;
819
- readonly formTarget?: MaybeReadonlyAtom<string>;
820
- readonly value?: MaybeReadonlyAtom<string>;
821
- readonly popoverTargetAction?: MaybeReadonlyAtom<string>;
822
- readonly popoverTargetElement?: MaybeReadonlyAtom<Element | null>;
823
- readonly align?: MaybeReadonlyAtom<string>;
824
- readonly autocomplete?: MaybeReadonlyAtom<AutoFill>;
825
- readonly size?: MaybeReadonlyAtom<number>;
826
- readonly useMap?: MaybeReadonlyAtom<string>;
827
- readonly accept?: MaybeReadonlyAtom<string>;
828
- readonly capture?: MaybeReadonlyAtom<string>;
829
- readonly checked?: MaybeReadonlyAtom<boolean>;
830
- readonly defaultChecked?: MaybeReadonlyAtom<boolean>;
831
- readonly defaultValue?: MaybeReadonlyAtom<string>;
832
- readonly dirName?: MaybeReadonlyAtom<string>;
833
- readonly files?: MaybeReadonlyAtom<FileList | null>;
834
- readonly indeterminate?: MaybeReadonlyAtom<boolean>;
835
- readonly max?: MaybeReadonlyAtom<string>;
836
- readonly maxLength?: MaybeReadonlyAtom<number>;
837
- readonly min?: MaybeReadonlyAtom<string>;
838
- readonly minLength?: MaybeReadonlyAtom<number>;
839
- readonly multiple?: MaybeReadonlyAtom<boolean>;
840
- readonly pattern?: MaybeReadonlyAtom<string>;
841
- readonly placeholder?: MaybeReadonlyAtom<string>;
842
- readonly readOnly?: MaybeReadonlyAtom<boolean>;
843
- readonly required?: MaybeReadonlyAtom<boolean>;
844
- readonly selectionDirection?: MaybeReadonlyAtom<SelectionDirection | null>;
845
- readonly selectionEnd?: MaybeReadonlyAtom<number | null>;
846
- readonly selectionStart?: MaybeReadonlyAtom<number | null>;
847
- readonly step?: MaybeReadonlyAtom<string>;
848
- readonly valueAsDate?: MaybeReadonlyAtom<Date | null>;
849
- readonly valueAsNumber?: MaybeReadonlyAtom<number>;
850
- readonly webkitdirectory?: MaybeReadonlyAtom<boolean>;
808
+ readonly height?: MaybeReadAtom<number>;
809
+ readonly width?: MaybeReadAtom<number>;
810
+ readonly name?: MaybeReadAtom<string>;
811
+ readonly type?: MaybeReadAtom<string>;
812
+ readonly alt?: MaybeReadAtom<string>;
813
+ readonly src?: MaybeReadAtom<string>;
814
+ readonly disabled?: MaybeReadAtom<boolean>;
815
+ readonly formAction?: MaybeReadAtom<string>;
816
+ readonly formEnctype?: MaybeReadAtom<string>;
817
+ readonly formMethod?: MaybeReadAtom<string>;
818
+ readonly formNoValidate?: MaybeReadAtom<boolean>;
819
+ readonly formTarget?: MaybeReadAtom<string>;
820
+ readonly value?: MaybeReadAtom<string>;
821
+ readonly popoverTargetAction?: MaybeReadAtom<string>;
822
+ readonly popoverTargetElement?: MaybeReadAtom<Element | null>;
823
+ readonly align?: MaybeReadAtom<string>;
824
+ readonly autocomplete?: MaybeReadAtom<AutoFill>;
825
+ readonly size?: MaybeReadAtom<number>;
826
+ readonly useMap?: MaybeReadAtom<string>;
827
+ readonly accept?: MaybeReadAtom<string>;
828
+ readonly capture?: MaybeReadAtom<string>;
829
+ readonly checked?: MaybeReadAtom<boolean>;
830
+ readonly defaultChecked?: MaybeReadAtom<boolean>;
831
+ readonly defaultValue?: MaybeReadAtom<string>;
832
+ readonly dirName?: MaybeReadAtom<string>;
833
+ readonly files?: MaybeReadAtom<FileList | null>;
834
+ readonly indeterminate?: MaybeReadAtom<boolean>;
835
+ readonly max?: MaybeReadAtom<string>;
836
+ readonly maxLength?: MaybeReadAtom<number>;
837
+ readonly min?: MaybeReadAtom<string>;
838
+ readonly minLength?: MaybeReadAtom<number>;
839
+ readonly multiple?: MaybeReadAtom<boolean>;
840
+ readonly pattern?: MaybeReadAtom<string>;
841
+ readonly placeholder?: MaybeReadAtom<string>;
842
+ readonly readOnly?: MaybeReadAtom<boolean>;
843
+ readonly required?: MaybeReadAtom<boolean>;
844
+ readonly selectionDirection?: MaybeReadAtom<SelectionDirection | null>;
845
+ readonly selectionEnd?: MaybeReadAtom<number | null>;
846
+ readonly selectionStart?: MaybeReadAtom<number | null>;
847
+ readonly step?: MaybeReadAtom<string>;
848
+ readonly valueAsDate?: MaybeReadAtom<Date | null>;
849
+ readonly valueAsNumber?: MaybeReadAtom<number>;
850
+ readonly webkitdirectory?: MaybeReadAtom<boolean>;
851
851
  }
852
852
  interface HTMLLabelElementProps extends HTMLGlobalProps {
853
853
  readonly [S_NODE_TYPE]?: HTMLLabelElement;
854
854
  readonly children?: JsxChildren;
855
- readonly for?: MaybeReadonlyAtom<string>;
855
+ readonly for?: MaybeReadAtom<string>;
856
856
  }
857
857
  interface HTMLLegendElementProps extends HTMLGlobalProps {
858
858
  readonly [S_NODE_TYPE]?: HTMLLegendElement;
859
859
  readonly children?: JsxChildren;
860
- readonly align?: MaybeReadonlyAtom<string>;
860
+ readonly align?: MaybeReadAtom<string>;
861
861
  }
862
862
  interface HTMLLIElementProps extends HTMLGlobalProps {
863
863
  readonly [S_NODE_TYPE]?: HTMLLIElement;
864
864
  readonly children?: JsxChildren;
865
- readonly type?: MaybeReadonlyAtom<string>;
866
- readonly value?: MaybeReadonlyAtom<number>;
865
+ readonly type?: MaybeReadAtom<string>;
866
+ readonly value?: MaybeReadAtom<number>;
867
867
  }
868
868
  interface HTMLMapElementProps extends HTMLGlobalProps {
869
869
  readonly [S_NODE_TYPE]?: HTMLMapElement;
870
870
  readonly children?: JsxChildren;
871
- readonly name?: MaybeReadonlyAtom<string>;
871
+ readonly name?: MaybeReadAtom<string>;
872
872
  }
873
873
  interface HTMLMenuElementProps extends HTMLGlobalProps {
874
874
  readonly [S_NODE_TYPE]?: HTMLMenuElement;
875
875
  readonly children?: JsxChildren;
876
- readonly compact?: MaybeReadonlyAtom<boolean>;
876
+ readonly compact?: MaybeReadAtom<boolean>;
877
877
  }
878
878
  interface HTMLMeterElementProps extends HTMLGlobalProps {
879
879
  readonly [S_NODE_TYPE]?: HTMLMeterElement;
880
880
  readonly children?: JsxChildren;
881
- readonly value?: MaybeReadonlyAtom<number>;
882
- readonly high?: MaybeReadonlyAtom<number>;
883
- readonly low?: MaybeReadonlyAtom<number>;
884
- readonly max?: MaybeReadonlyAtom<number>;
885
- readonly min?: MaybeReadonlyAtom<number>;
886
- readonly optimum?: MaybeReadonlyAtom<number>;
881
+ readonly value?: MaybeReadAtom<number>;
882
+ readonly high?: MaybeReadAtom<number>;
883
+ readonly low?: MaybeReadAtom<number>;
884
+ readonly max?: MaybeReadAtom<number>;
885
+ readonly min?: MaybeReadAtom<number>;
886
+ readonly optimum?: MaybeReadAtom<number>;
887
887
  }
888
888
  interface HTMLObjectElementProps extends HTMLGlobalProps {
889
889
  readonly [S_NODE_TYPE]?: HTMLObjectElement;
890
890
  readonly children?: JsxChildren;
891
- readonly border?: MaybeReadonlyAtom<string>;
892
- readonly height?: MaybeReadonlyAtom<string>;
893
- readonly width?: MaybeReadonlyAtom<string>;
894
- readonly name?: MaybeReadonlyAtom<string>;
895
- readonly type?: MaybeReadonlyAtom<string>;
896
- readonly align?: MaybeReadonlyAtom<string>;
897
- readonly hspace?: MaybeReadonlyAtom<number>;
898
- readonly useMap?: MaybeReadonlyAtom<string>;
899
- readonly vspace?: MaybeReadonlyAtom<number>;
900
- readonly archive?: MaybeReadonlyAtom<string>;
901
- readonly code?: MaybeReadonlyAtom<string>;
902
- readonly codeBase?: MaybeReadonlyAtom<string>;
903
- readonly codeType?: MaybeReadonlyAtom<string>;
904
- readonly data?: MaybeReadonlyAtom<string>;
905
- readonly declare?: MaybeReadonlyAtom<boolean>;
906
- readonly standby?: MaybeReadonlyAtom<string>;
891
+ readonly border?: MaybeReadAtom<string>;
892
+ readonly height?: MaybeReadAtom<string>;
893
+ readonly width?: MaybeReadAtom<string>;
894
+ readonly name?: MaybeReadAtom<string>;
895
+ readonly type?: MaybeReadAtom<string>;
896
+ readonly align?: MaybeReadAtom<string>;
897
+ readonly hspace?: MaybeReadAtom<number>;
898
+ readonly useMap?: MaybeReadAtom<string>;
899
+ readonly vspace?: MaybeReadAtom<number>;
900
+ readonly archive?: MaybeReadAtom<string>;
901
+ readonly code?: MaybeReadAtom<string>;
902
+ readonly codeBase?: MaybeReadAtom<string>;
903
+ readonly codeType?: MaybeReadAtom<string>;
904
+ readonly data?: MaybeReadAtom<string>;
905
+ readonly declare?: MaybeReadAtom<boolean>;
906
+ readonly standby?: MaybeReadAtom<string>;
907
907
  }
908
908
  interface HTMLOListElementProps extends HTMLGlobalProps {
909
909
  readonly [S_NODE_TYPE]?: HTMLOListElement;
910
910
  readonly children?: JsxChildren;
911
- readonly type?: MaybeReadonlyAtom<string>;
912
- readonly compact?: MaybeReadonlyAtom<boolean>;
913
- readonly reversed?: MaybeReadonlyAtom<boolean>;
914
- readonly start?: MaybeReadonlyAtom<number>;
911
+ readonly type?: MaybeReadAtom<string>;
912
+ readonly compact?: MaybeReadAtom<boolean>;
913
+ readonly reversed?: MaybeReadAtom<boolean>;
914
+ readonly start?: MaybeReadAtom<number>;
915
915
  }
916
916
  interface HTMLOptGroupElementProps extends HTMLGlobalProps {
917
917
  readonly [S_NODE_TYPE]?: HTMLOptGroupElement;
918
918
  readonly children?: JsxChildren;
919
- readonly disabled?: MaybeReadonlyAtom<boolean>;
920
- readonly label?: MaybeReadonlyAtom<string>;
919
+ readonly disabled?: MaybeReadAtom<boolean>;
920
+ readonly label?: MaybeReadAtom<string>;
921
921
  }
922
922
  interface HTMLOptionElementProps extends HTMLGlobalProps {
923
923
  readonly [S_NODE_TYPE]?: HTMLOptionElement;
924
924
  readonly children?: JsxChildren;
925
- readonly text?: MaybeReadonlyAtom<string>;
926
- readonly disabled?: MaybeReadonlyAtom<boolean>;
927
- readonly value?: MaybeReadonlyAtom<string>;
928
- readonly label?: MaybeReadonlyAtom<string>;
929
- readonly defaultSelected?: MaybeReadonlyAtom<boolean>;
930
- readonly selected?: MaybeReadonlyAtom<boolean>;
925
+ readonly text?: MaybeReadAtom<string>;
926
+ readonly disabled?: MaybeReadAtom<boolean>;
927
+ readonly value?: MaybeReadAtom<string>;
928
+ readonly label?: MaybeReadAtom<string>;
929
+ readonly defaultSelected?: MaybeReadAtom<boolean>;
930
+ readonly selected?: MaybeReadAtom<boolean>;
931
931
  }
932
932
  interface HTMLOutputElementProps extends HTMLGlobalProps {
933
933
  readonly [S_NODE_TYPE]?: HTMLOutputElement;
934
934
  readonly children?: JsxChildren;
935
- readonly for?: MaybeReadonlyAtom<DOMTokenList>;
936
- readonly name?: MaybeReadonlyAtom<string>;
937
- readonly value?: MaybeReadonlyAtom<string>;
938
- readonly defaultValue?: MaybeReadonlyAtom<string>;
935
+ readonly for?: MaybeReadAtom<DOMTokenList>;
936
+ readonly name?: MaybeReadAtom<string>;
937
+ readonly value?: MaybeReadAtom<string>;
938
+ readonly defaultValue?: MaybeReadAtom<string>;
939
939
  }
940
940
  interface HTMLParagraphElementProps extends HTMLGlobalProps {
941
941
  readonly [S_NODE_TYPE]?: HTMLParagraphElement;
942
942
  readonly children?: JsxChildren;
943
- readonly align?: MaybeReadonlyAtom<string>;
943
+ readonly align?: MaybeReadAtom<string>;
944
944
  }
945
945
  interface HTMLPictureElementProps extends HTMLGlobalProps {
946
946
  readonly [S_NODE_TYPE]?: HTMLPictureElement;
@@ -949,42 +949,42 @@ interface HTMLPictureElementProps extends HTMLGlobalProps {
949
949
  interface HTMLPreElementProps extends HTMLGlobalProps {
950
950
  readonly [S_NODE_TYPE]?: HTMLPreElement;
951
951
  readonly children?: JsxChildren;
952
- readonly width?: MaybeReadonlyAtom<number>;
952
+ readonly width?: MaybeReadAtom<number>;
953
953
  }
954
954
  interface HTMLProgressElementProps extends HTMLGlobalProps {
955
955
  readonly [S_NODE_TYPE]?: HTMLProgressElement;
956
956
  readonly children?: JsxChildren;
957
- readonly value?: MaybeReadonlyAtom<number>;
958
- readonly max?: MaybeReadonlyAtom<number>;
957
+ readonly value?: MaybeReadAtom<number>;
958
+ readonly max?: MaybeReadAtom<number>;
959
959
  }
960
960
  interface HTMLSelectElementProps extends HTMLGlobalProps {
961
961
  readonly [S_NODE_TYPE]?: HTMLSelectElement;
962
962
  readonly children?: JsxChildren;
963
- readonly length?: MaybeReadonlyAtom<number>;
964
- readonly name?: MaybeReadonlyAtom<string>;
965
- readonly disabled?: MaybeReadonlyAtom<boolean>;
966
- readonly value?: MaybeReadonlyAtom<string>;
967
- readonly autocomplete?: MaybeReadonlyAtom<AutoFill>;
968
- readonly size?: MaybeReadonlyAtom<number>;
969
- readonly multiple?: MaybeReadonlyAtom<boolean>;
970
- readonly required?: MaybeReadonlyAtom<boolean>;
971
- readonly selectedIndex?: MaybeReadonlyAtom<number>;
963
+ readonly length?: MaybeReadAtom<number>;
964
+ readonly name?: MaybeReadAtom<string>;
965
+ readonly disabled?: MaybeReadAtom<boolean>;
966
+ readonly value?: MaybeReadAtom<string>;
967
+ readonly autocomplete?: MaybeReadAtom<AutoFill>;
968
+ readonly size?: MaybeReadAtom<number>;
969
+ readonly multiple?: MaybeReadAtom<boolean>;
970
+ readonly required?: MaybeReadAtom<boolean>;
971
+ readonly selectedIndex?: MaybeReadAtom<number>;
972
972
  }
973
973
  interface HTMLSlotElementProps extends HTMLGlobalProps {
974
974
  readonly [S_NODE_TYPE]?: HTMLSlotElement;
975
975
  readonly children?: JsxChildren;
976
- readonly name?: MaybeReadonlyAtom<string>;
976
+ readonly name?: MaybeReadAtom<string>;
977
977
  }
978
978
  interface HTMLSourceElementProps extends HTMLGlobalProps {
979
979
  readonly [S_NODE_TYPE]?: HTMLSourceElement;
980
980
  readonly children?: never;
981
- readonly height?: MaybeReadonlyAtom<number>;
982
- readonly width?: MaybeReadonlyAtom<number>;
983
- readonly type?: MaybeReadonlyAtom<string>;
984
- readonly src?: MaybeReadonlyAtom<string>;
985
- readonly sizes?: MaybeReadonlyAtom<string>;
986
- readonly srcset?: MaybeReadonlyAtom<string>;
987
- readonly media?: MaybeReadonlyAtom<string>;
981
+ readonly height?: MaybeReadAtom<number>;
982
+ readonly width?: MaybeReadAtom<number>;
983
+ readonly type?: MaybeReadAtom<string>;
984
+ readonly src?: MaybeReadAtom<string>;
985
+ readonly sizes?: MaybeReadAtom<string>;
986
+ readonly srcset?: MaybeReadAtom<string>;
987
+ readonly media?: MaybeReadAtom<string>;
988
988
  }
989
989
  interface HTMLSpanElementProps extends HTMLGlobalProps {
990
990
  readonly [S_NODE_TYPE]?: HTMLSpanElement;
@@ -993,133 +993,134 @@ interface HTMLSpanElementProps extends HTMLGlobalProps {
993
993
  interface HTMLTableElementProps extends HTMLGlobalProps {
994
994
  readonly [S_NODE_TYPE]?: HTMLTableElement;
995
995
  readonly children?: JsxChildren;
996
- readonly border?: MaybeReadonlyAtom<string>;
997
- readonly width?: MaybeReadonlyAtom<string>;
998
- readonly align?: MaybeReadonlyAtom<string>;
999
- readonly bgColor?: MaybeReadonlyAtom<string>;
1000
- readonly caption?: MaybeReadonlyAtom<HTMLTableCaptionElement | null>;
1001
- readonly cellPadding?: MaybeReadonlyAtom<string>;
1002
- readonly cellSpacing?: MaybeReadonlyAtom<string>;
1003
- readonly frame?: MaybeReadonlyAtom<string>;
1004
- readonly rules?: MaybeReadonlyAtom<string>;
1005
- readonly summary?: MaybeReadonlyAtom<string>;
1006
- readonly tFoot?: MaybeReadonlyAtom<HTMLTableSectionElement | null>;
1007
- readonly tHead?: MaybeReadonlyAtom<HTMLTableSectionElement | null>;
996
+ readonly border?: MaybeReadAtom<string>;
997
+ readonly width?: MaybeReadAtom<string>;
998
+ readonly align?: MaybeReadAtom<string>;
999
+ readonly bgColor?: MaybeReadAtom<string>;
1000
+ readonly caption?: MaybeReadAtom<HTMLTableCaptionElement | null>;
1001
+ readonly cellPadding?: MaybeReadAtom<string>;
1002
+ readonly cellSpacing?: MaybeReadAtom<string>;
1003
+ readonly frame?: MaybeReadAtom<string>;
1004
+ readonly rules?: MaybeReadAtom<string>;
1005
+ readonly summary?: MaybeReadAtom<string>;
1006
+ readonly tFoot?: MaybeReadAtom<HTMLTableSectionElement | null>;
1007
+ readonly tHead?: MaybeReadAtom<HTMLTableSectionElement | null>;
1008
1008
  }
1009
1009
  interface HTMLTableSectionElementProps extends HTMLGlobalProps {
1010
1010
  readonly [S_NODE_TYPE]?: HTMLTableSectionElement;
1011
1011
  readonly children?: JsxChildren;
1012
- readonly align?: MaybeReadonlyAtom<string>;
1013
- readonly ch?: MaybeReadonlyAtom<string>;
1014
- readonly chOff?: MaybeReadonlyAtom<string>;
1015
- readonly vAlign?: MaybeReadonlyAtom<string>;
1012
+ readonly align?: MaybeReadAtom<string>;
1013
+ readonly ch?: MaybeReadAtom<string>;
1014
+ readonly chOff?: MaybeReadAtom<string>;
1015
+ readonly vAlign?: MaybeReadAtom<string>;
1016
1016
  }
1017
1017
  interface HTMLTableCellElementProps extends HTMLGlobalProps {
1018
1018
  readonly [S_NODE_TYPE]?: HTMLTableCellElement;
1019
1019
  readonly children?: JsxChildren;
1020
- readonly height?: MaybeReadonlyAtom<string>;
1021
- readonly width?: MaybeReadonlyAtom<string>;
1022
- readonly align?: MaybeReadonlyAtom<string>;
1023
- readonly ch?: MaybeReadonlyAtom<string>;
1024
- readonly chOff?: MaybeReadonlyAtom<string>;
1025
- readonly vAlign?: MaybeReadonlyAtom<string>;
1026
- readonly bgColor?: MaybeReadonlyAtom<string>;
1027
- readonly abbr?: MaybeReadonlyAtom<string>;
1028
- readonly axis?: MaybeReadonlyAtom<string>;
1029
- readonly colSpan?: MaybeReadonlyAtom<number>;
1030
- readonly headers?: MaybeReadonlyAtom<string>;
1031
- readonly noWrap?: MaybeReadonlyAtom<boolean>;
1032
- readonly rowSpan?: MaybeReadonlyAtom<number>;
1033
- readonly scope?: MaybeReadonlyAtom<string>;
1020
+ readonly height?: MaybeReadAtom<string>;
1021
+ readonly width?: MaybeReadAtom<string>;
1022
+ readonly align?: MaybeReadAtom<string>;
1023
+ readonly ch?: MaybeReadAtom<string>;
1024
+ readonly chOff?: MaybeReadAtom<string>;
1025
+ readonly vAlign?: MaybeReadAtom<string>;
1026
+ readonly bgColor?: MaybeReadAtom<string>;
1027
+ readonly abbr?: MaybeReadAtom<string>;
1028
+ readonly axis?: MaybeReadAtom<string>;
1029
+ readonly colSpan?: MaybeReadAtom<number>;
1030
+ readonly headers?: MaybeReadAtom<string>;
1031
+ readonly noWrap?: MaybeReadAtom<boolean>;
1032
+ readonly rowSpan?: MaybeReadAtom<number>;
1033
+ readonly scope?: MaybeReadAtom<string>;
1034
1034
  }
1035
1035
  interface HTMLTemplateElementProps extends HTMLGlobalProps {
1036
1036
  readonly [S_NODE_TYPE]?: HTMLTemplateElement;
1037
1037
  readonly children?: JsxChildren;
1038
- readonly shadowRootClonable?: MaybeReadonlyAtom<boolean>;
1039
- readonly shadowRootCustomElementRegistry?: MaybeReadonlyAtom<string>;
1040
- readonly shadowRootDelegatesFocus?: MaybeReadonlyAtom<boolean>;
1041
- readonly shadowRootMode?: MaybeReadonlyAtom<string>;
1042
- readonly shadowRootSerializable?: MaybeReadonlyAtom<boolean>;
1038
+ readonly shadowRootClonable?: MaybeReadAtom<boolean>;
1039
+ readonly shadowRootCustomElementRegistry?: MaybeReadAtom<string>;
1040
+ readonly shadowRootDelegatesFocus?: MaybeReadAtom<boolean>;
1041
+ readonly shadowRootMode?: MaybeReadAtom<string>;
1042
+ readonly shadowRootSerializable?: MaybeReadAtom<boolean>;
1043
1043
  }
1044
1044
  interface HTMLTextAreaElementProps extends HTMLGlobalProps {
1045
1045
  readonly [S_NODE_TYPE]?: HTMLTextAreaElement;
1046
1046
  readonly children?: JsxChildren;
1047
- readonly name?: MaybeReadonlyAtom<string>;
1048
- readonly disabled?: MaybeReadonlyAtom<boolean>;
1049
- readonly value?: MaybeReadonlyAtom<string>;
1050
- readonly autocomplete?: MaybeReadonlyAtom<AutoFill>;
1051
- readonly defaultValue?: MaybeReadonlyAtom<string>;
1052
- readonly dirName?: MaybeReadonlyAtom<string>;
1053
- readonly maxLength?: MaybeReadonlyAtom<number>;
1054
- readonly minLength?: MaybeReadonlyAtom<number>;
1055
- readonly placeholder?: MaybeReadonlyAtom<string>;
1056
- readonly readOnly?: MaybeReadonlyAtom<boolean>;
1057
- readonly required?: MaybeReadonlyAtom<boolean>;
1058
- readonly selectionDirection?: MaybeReadonlyAtom<SelectionDirection>;
1059
- readonly selectionEnd?: MaybeReadonlyAtom<number>;
1060
- readonly selectionStart?: MaybeReadonlyAtom<number>;
1061
- readonly rows?: MaybeReadonlyAtom<number>;
1062
- readonly cols?: MaybeReadonlyAtom<number>;
1063
- readonly wrap?: MaybeReadonlyAtom<string>;
1047
+ readonly name?: MaybeReadAtom<string>;
1048
+ readonly disabled?: MaybeReadAtom<boolean>;
1049
+ readonly value?: MaybeReadAtom<string>;
1050
+ readonly autocomplete?: MaybeReadAtom<AutoFill>;
1051
+ readonly defaultValue?: MaybeReadAtom<string>;
1052
+ readonly dirName?: MaybeReadAtom<string>;
1053
+ readonly maxLength?: MaybeReadAtom<number>;
1054
+ readonly minLength?: MaybeReadAtom<number>;
1055
+ readonly placeholder?: MaybeReadAtom<string>;
1056
+ readonly readOnly?: MaybeReadAtom<boolean>;
1057
+ readonly required?: MaybeReadAtom<boolean>;
1058
+ readonly selectionDirection?: MaybeReadAtom<SelectionDirection>;
1059
+ readonly selectionEnd?: MaybeReadAtom<number>;
1060
+ readonly selectionStart?: MaybeReadAtom<number>;
1061
+ readonly rows?: MaybeReadAtom<number>;
1062
+ readonly cols?: MaybeReadAtom<number>;
1063
+ readonly wrap?: MaybeReadAtom<string>;
1064
1064
  }
1065
1065
  interface HTMLTimeElementProps extends HTMLGlobalProps {
1066
1066
  readonly [S_NODE_TYPE]?: HTMLTimeElement;
1067
1067
  readonly children?: JsxChildren;
1068
- readonly dateTime?: MaybeReadonlyAtom<string>;
1068
+ readonly dateTime?: MaybeReadAtom<string>;
1069
1069
  }
1070
1070
  interface HTMLTableRowElementProps extends HTMLGlobalProps {
1071
1071
  readonly [S_NODE_TYPE]?: HTMLTableRowElement;
1072
1072
  readonly children?: JsxChildren;
1073
- readonly align?: MaybeReadonlyAtom<string>;
1074
- readonly ch?: MaybeReadonlyAtom<string>;
1075
- readonly chOff?: MaybeReadonlyAtom<string>;
1076
- readonly vAlign?: MaybeReadonlyAtom<string>;
1077
- readonly bgColor?: MaybeReadonlyAtom<string>;
1073
+ readonly align?: MaybeReadAtom<string>;
1074
+ readonly ch?: MaybeReadAtom<string>;
1075
+ readonly chOff?: MaybeReadAtom<string>;
1076
+ readonly vAlign?: MaybeReadAtom<string>;
1077
+ readonly bgColor?: MaybeReadAtom<string>;
1078
1078
  }
1079
1079
  interface HTMLTrackElementProps extends HTMLGlobalProps {
1080
1080
  readonly [S_NODE_TYPE]?: HTMLTrackElement;
1081
1081
  readonly children?: never;
1082
- readonly src?: MaybeReadonlyAtom<string>;
1083
- readonly label?: MaybeReadonlyAtom<string>;
1084
- readonly default?: MaybeReadonlyAtom<boolean>;
1085
- readonly kind?: MaybeReadonlyAtom<string>;
1086
- readonly srclang?: MaybeReadonlyAtom<string>;
1082
+ readonly src?: MaybeReadAtom<string>;
1083
+ readonly label?: MaybeReadAtom<string>;
1084
+ readonly default?: MaybeReadAtom<boolean>;
1085
+ readonly kind?: MaybeReadAtom<string>;
1086
+ readonly srclang?: MaybeReadAtom<string>;
1087
1087
  }
1088
1088
  interface HTMLUListElementProps extends HTMLGlobalProps {
1089
1089
  readonly [S_NODE_TYPE]?: HTMLUListElement;
1090
1090
  readonly children?: JsxChildren;
1091
- readonly type?: MaybeReadonlyAtom<string>;
1092
- readonly compact?: MaybeReadonlyAtom<boolean>;
1091
+ readonly type?: MaybeReadAtom<string>;
1092
+ readonly compact?: MaybeReadAtom<boolean>;
1093
1093
  }
1094
1094
  interface HTMLVideoElementProps extends HTMLGlobalProps {
1095
1095
  readonly [S_NODE_TYPE]?: HTMLVideoElement;
1096
1096
  readonly children?: JsxChildren;
1097
- readonly height?: MaybeReadonlyAtom<number>;
1098
- readonly width?: MaybeReadonlyAtom<number>;
1099
- readonly autoplay?: MaybeReadonlyAtom<boolean>;
1100
- readonly controls?: MaybeReadonlyAtom<boolean>;
1101
- readonly crossOrigin?: MaybeReadonlyAtom<string | null>;
1102
- readonly currentTime?: MaybeReadonlyAtom<number>;
1103
- readonly defaultMuted?: MaybeReadonlyAtom<boolean>;
1104
- readonly defaultPlaybackRate?: MaybeReadonlyAtom<number>;
1105
- readonly disableRemotePlayback?: MaybeReadonlyAtom<boolean>;
1106
- readonly loop?: MaybeReadonlyAtom<boolean>;
1107
- readonly muted?: MaybeReadonlyAtom<boolean>;
1108
- readonly playbackRate?: MaybeReadonlyAtom<number>;
1109
- readonly preload?: MaybeReadonlyAtom<"" | "none" | "metadata" | "auto">;
1110
- readonly preservesPitch?: MaybeReadonlyAtom<boolean>;
1111
- readonly src?: MaybeReadonlyAtom<string>;
1112
- readonly srcObject?: MaybeReadonlyAtom<MediaProvider | null>;
1113
- readonly volume?: MaybeReadonlyAtom<number>;
1114
- readonly disablePictureInPicture?: MaybeReadonlyAtom<boolean>;
1115
- readonly playsInline?: MaybeReadonlyAtom<boolean>;
1116
- readonly poster?: MaybeReadonlyAtom<string>;
1097
+ readonly height?: MaybeReadAtom<number>;
1098
+ readonly width?: MaybeReadAtom<number>;
1099
+ readonly autoplay?: MaybeReadAtom<boolean>;
1100
+ readonly controls?: MaybeReadAtom<boolean>;
1101
+ readonly crossOrigin?: MaybeReadAtom<string | null>;
1102
+ readonly currentTime?: MaybeReadAtom<number>;
1103
+ readonly defaultMuted?: MaybeReadAtom<boolean>;
1104
+ readonly defaultPlaybackRate?: MaybeReadAtom<number>;
1105
+ readonly disableRemotePlayback?: MaybeReadAtom<boolean>;
1106
+ readonly loop?: MaybeReadAtom<boolean>;
1107
+ readonly muted?: MaybeReadAtom<boolean>;
1108
+ readonly playbackRate?: MaybeReadAtom<number>;
1109
+ readonly preload?: MaybeReadAtom<"" | "none" | "metadata" | "auto">;
1110
+ readonly preservesPitch?: MaybeReadAtom<boolean>;
1111
+ readonly src?: MaybeReadAtom<string>;
1112
+ readonly srcObject?: MaybeReadAtom<MediaProvider | null>;
1113
+ readonly volume?: MaybeReadAtom<number>;
1114
+ readonly disablePictureInPicture?: MaybeReadAtom<boolean>;
1115
+ readonly playsInline?: MaybeReadAtom<boolean>;
1116
+ readonly poster?: MaybeReadAtom<string>;
1117
1117
  }
1118
1118
  interface HTMLWbrElementProps extends HTMLGlobalProps {
1119
1119
  readonly [S_NODE_TYPE]?: HTMLElement;
1120
1120
  readonly children?: never;
1121
1121
  }
1122
1122
  interface HTMLIntrinsicElements {
1123
+ a: HTMLAnchorElementProps;
1123
1124
  abbr: HTMLElementProps;
1124
1125
  address: HTMLElementProps;
1125
1126
  area: HTMLAreaElementProps;
@@ -1225,17 +1226,17 @@ interface HTMLIntrinsicElements {
1225
1226
  wbr: HTMLWbrElementProps;
1226
1227
  }
1227
1228
  interface SVGGlobalProps {
1228
- readonly autofocus?: MaybeReadonlyAtom<boolean>;
1229
- readonly class?: MaybeReadonlyAtom<string>;
1230
- readonly color?: MaybeReadonlyAtom<string>;
1231
- readonly display?: MaybeReadonlyAtom<string>;
1232
- readonly filter?: MaybeReadonlyAtom<string>;
1233
- readonly id?: MaybeReadonlyAtom<string>;
1234
- readonly lang?: MaybeReadonlyAtom<string>;
1235
- readonly style?: MaybeReadonlyAtom<string>;
1236
- readonly tabindex?: MaybeReadonlyAtom<string | number>;
1237
- readonly transform?: MaybeReadonlyAtom<string>;
1238
- readonly "transform-origin"?: MaybeReadonlyAtom<string>;
1229
+ readonly autofocus?: MaybeReadAtom<boolean>;
1230
+ readonly class?: MaybeReadAtom<string>;
1231
+ readonly color?: MaybeReadAtom<string>;
1232
+ readonly display?: MaybeReadAtom<string>;
1233
+ readonly filter?: MaybeReadAtom<string>;
1234
+ readonly id?: MaybeReadAtom<string>;
1235
+ readonly lang?: MaybeReadAtom<string>;
1236
+ readonly style?: MaybeReadAtom<string>;
1237
+ readonly tabindex?: MaybeReadAtom<string | number>;
1238
+ readonly transform?: MaybeReadAtom<string>;
1239
+ readonly "transform-origin"?: MaybeReadAtom<string>;
1239
1240
  }
1240
1241
  type SVGAccumulate = "none" | "sum";
1241
1242
  type SVGAdditive = "replace" | "sum";
@@ -1269,149 +1270,149 @@ type SVGColorChannel = "R" | "G" | "B" | "A";
1269
1270
  interface SVGAElementProps extends SVGGlobalProps {
1270
1271
  readonly [S_NODE_TYPE]?: SVGAElement;
1271
1272
  readonly children?: JsxChildren;
1272
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
1273
- readonly cursor?: MaybeReadonlyAtom<string>;
1274
- readonly href?: MaybeReadonlyAtom<string>;
1275
- readonly mask?: MaybeReadonlyAtom<string>;
1276
- readonly opacity?: MaybeReadonlyAtom<string | number>;
1277
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
1278
- readonly referrerpolicy?: MaybeReadonlyAtom<ReferrerPolicy>;
1279
- readonly rel?: MaybeReadonlyAtom<string>;
1280
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
1281
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
1282
- readonly target?: MaybeReadonlyAtom<string>;
1283
- readonly visibility?: MaybeReadonlyAtom<SVGVisibility>;
1273
+ readonly "clip-path"?: MaybeReadAtom<string>;
1274
+ readonly cursor?: MaybeReadAtom<string>;
1275
+ readonly href?: MaybeReadAtom<string>;
1276
+ readonly mask?: MaybeReadAtom<string>;
1277
+ readonly opacity?: MaybeReadAtom<string | number>;
1278
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
1279
+ readonly referrerpolicy?: MaybeReadAtom<ReferrerPolicy>;
1280
+ readonly rel?: MaybeReadAtom<string>;
1281
+ readonly requiredExtensions?: MaybeReadAtom<string>;
1282
+ readonly systemLanguage?: MaybeReadAtom<string>;
1283
+ readonly target?: MaybeReadAtom<string>;
1284
+ readonly visibility?: MaybeReadAtom<SVGVisibility>;
1284
1285
  }
1285
1286
  interface SVGAnimateElementProps extends SVGGlobalProps {
1286
1287
  readonly [S_NODE_TYPE]?: SVGAnimateElement;
1287
1288
  readonly children?: JsxChildren;
1288
- readonly accumulate?: MaybeReadonlyAtom<SVGAccumulate>;
1289
- readonly additive?: MaybeReadonlyAtom<SVGAdditive>;
1290
- readonly attributeName?: MaybeReadonlyAtom<string>;
1291
- readonly begin?: MaybeReadonlyAtom<string>;
1292
- readonly by?: MaybeReadonlyAtom<string | number>;
1293
- readonly calcMode?: MaybeReadonlyAtom<SVGCalcMode>;
1294
- readonly dur?: MaybeReadonlyAtom<string | number>;
1295
- readonly end?: MaybeReadonlyAtom<string>;
1296
- readonly fill?: MaybeReadonlyAtom<SVGFillMode>;
1297
- readonly from?: MaybeReadonlyAtom<string | number>;
1298
- readonly href?: MaybeReadonlyAtom<string>;
1299
- readonly keyPoints?: MaybeReadonlyAtom<string>;
1300
- readonly keySplines?: MaybeReadonlyAtom<string>;
1301
- readonly keyTimes?: MaybeReadonlyAtom<string>;
1302
- readonly max?: MaybeReadonlyAtom<string>;
1303
- readonly min?: MaybeReadonlyAtom<string>;
1304
- readonly repeatCount?: MaybeReadonlyAtom<number | "indefinite">;
1305
- readonly repeatDur?: MaybeReadonlyAtom<string | number>;
1306
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
1307
- readonly restart?: MaybeReadonlyAtom<SVGRestart>;
1308
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
1309
- readonly to?: MaybeReadonlyAtom<string | number>;
1310
- readonly values?: MaybeReadonlyAtom<string>;
1289
+ readonly accumulate?: MaybeReadAtom<SVGAccumulate>;
1290
+ readonly additive?: MaybeReadAtom<SVGAdditive>;
1291
+ readonly attributeName?: MaybeReadAtom<string>;
1292
+ readonly begin?: MaybeReadAtom<string>;
1293
+ readonly by?: MaybeReadAtom<string | number>;
1294
+ readonly calcMode?: MaybeReadAtom<SVGCalcMode>;
1295
+ readonly dur?: MaybeReadAtom<string | number>;
1296
+ readonly end?: MaybeReadAtom<string>;
1297
+ readonly fill?: MaybeReadAtom<SVGFillMode>;
1298
+ readonly from?: MaybeReadAtom<string | number>;
1299
+ readonly href?: MaybeReadAtom<string>;
1300
+ readonly keyPoints?: MaybeReadAtom<string>;
1301
+ readonly keySplines?: MaybeReadAtom<string>;
1302
+ readonly keyTimes?: MaybeReadAtom<string>;
1303
+ readonly max?: MaybeReadAtom<string>;
1304
+ readonly min?: MaybeReadAtom<string>;
1305
+ readonly repeatCount?: MaybeReadAtom<number | "indefinite">;
1306
+ readonly repeatDur?: MaybeReadAtom<string | number>;
1307
+ readonly requiredExtensions?: MaybeReadAtom<string>;
1308
+ readonly restart?: MaybeReadAtom<SVGRestart>;
1309
+ readonly systemLanguage?: MaybeReadAtom<string>;
1310
+ readonly to?: MaybeReadAtom<string | number>;
1311
+ readonly values?: MaybeReadAtom<string>;
1311
1312
  }
1312
1313
  interface SVGAnimateMotionElementProps extends SVGGlobalProps {
1313
1314
  readonly [S_NODE_TYPE]?: SVGAnimateMotionElement;
1314
1315
  readonly children?: JsxChildren;
1315
- readonly accumulate?: MaybeReadonlyAtom<SVGAccumulate>;
1316
- readonly additive?: MaybeReadonlyAtom<SVGAdditive>;
1317
- readonly begin?: MaybeReadonlyAtom<string>;
1318
- readonly by?: MaybeReadonlyAtom<string | number>;
1319
- readonly calcMode?: MaybeReadonlyAtom<SVGCalcMode>;
1320
- readonly dur?: MaybeReadonlyAtom<string | number>;
1321
- readonly end?: MaybeReadonlyAtom<string>;
1322
- readonly fill?: MaybeReadonlyAtom<SVGFillMode>;
1323
- readonly from?: MaybeReadonlyAtom<string | number>;
1324
- readonly href?: MaybeReadonlyAtom<string>;
1325
- readonly keyPoints?: MaybeReadonlyAtom<string>;
1326
- readonly keySplines?: MaybeReadonlyAtom<string>;
1327
- readonly keyTimes?: MaybeReadonlyAtom<string>;
1328
- readonly max?: MaybeReadonlyAtom<string>;
1329
- readonly min?: MaybeReadonlyAtom<string>;
1330
- readonly path?: MaybeReadonlyAtom<string>;
1331
- readonly repeatCount?: MaybeReadonlyAtom<number | "indefinite">;
1332
- readonly repeatDur?: MaybeReadonlyAtom<string | number>;
1333
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
1334
- readonly restart?: MaybeReadonlyAtom<SVGRestart>;
1335
- readonly rotate?: MaybeReadonlyAtom<number | "auto" | "auto-reverse">;
1336
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
1337
- readonly to?: MaybeReadonlyAtom<string | number>;
1338
- readonly values?: MaybeReadonlyAtom<string>;
1316
+ readonly accumulate?: MaybeReadAtom<SVGAccumulate>;
1317
+ readonly additive?: MaybeReadAtom<SVGAdditive>;
1318
+ readonly begin?: MaybeReadAtom<string>;
1319
+ readonly by?: MaybeReadAtom<string | number>;
1320
+ readonly calcMode?: MaybeReadAtom<SVGCalcMode>;
1321
+ readonly dur?: MaybeReadAtom<string | number>;
1322
+ readonly end?: MaybeReadAtom<string>;
1323
+ readonly fill?: MaybeReadAtom<SVGFillMode>;
1324
+ readonly from?: MaybeReadAtom<string | number>;
1325
+ readonly href?: MaybeReadAtom<string>;
1326
+ readonly keyPoints?: MaybeReadAtom<string>;
1327
+ readonly keySplines?: MaybeReadAtom<string>;
1328
+ readonly keyTimes?: MaybeReadAtom<string>;
1329
+ readonly max?: MaybeReadAtom<string>;
1330
+ readonly min?: MaybeReadAtom<string>;
1331
+ readonly path?: MaybeReadAtom<string>;
1332
+ readonly repeatCount?: MaybeReadAtom<number | "indefinite">;
1333
+ readonly repeatDur?: MaybeReadAtom<string | number>;
1334
+ readonly requiredExtensions?: MaybeReadAtom<string>;
1335
+ readonly restart?: MaybeReadAtom<SVGRestart>;
1336
+ readonly rotate?: MaybeReadAtom<number | "auto" | "auto-reverse">;
1337
+ readonly systemLanguage?: MaybeReadAtom<string>;
1338
+ readonly to?: MaybeReadAtom<string | number>;
1339
+ readonly values?: MaybeReadAtom<string>;
1339
1340
  }
1340
1341
  interface SVGAnimateTransformElementProps extends SVGGlobalProps {
1341
1342
  readonly [S_NODE_TYPE]?: SVGAnimateTransformElement;
1342
1343
  readonly children?: JsxChildren;
1343
- readonly accumulate?: MaybeReadonlyAtom<SVGAccumulate>;
1344
- readonly additive?: MaybeReadonlyAtom<SVGAdditive>;
1345
- readonly attributeName?: MaybeReadonlyAtom<string>;
1346
- readonly begin?: MaybeReadonlyAtom<string>;
1347
- readonly by?: MaybeReadonlyAtom<string | number>;
1348
- readonly calcMode?: MaybeReadonlyAtom<SVGCalcMode>;
1349
- readonly dur?: MaybeReadonlyAtom<string | number>;
1350
- readonly end?: MaybeReadonlyAtom<string>;
1351
- readonly fill?: MaybeReadonlyAtom<SVGFillMode>;
1352
- readonly from?: MaybeReadonlyAtom<string | number>;
1353
- readonly href?: MaybeReadonlyAtom<string>;
1354
- readonly keyPoints?: MaybeReadonlyAtom<string>;
1355
- readonly keySplines?: MaybeReadonlyAtom<string>;
1356
- readonly keyTimes?: MaybeReadonlyAtom<string>;
1357
- readonly max?: MaybeReadonlyAtom<string>;
1358
- readonly min?: MaybeReadonlyAtom<string>;
1359
- readonly repeatCount?: MaybeReadonlyAtom<number | "indefinite">;
1360
- readonly repeatDur?: MaybeReadonlyAtom<string | number>;
1361
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
1362
- readonly restart?: MaybeReadonlyAtom<SVGRestart>;
1363
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
1364
- readonly to?: MaybeReadonlyAtom<string | number>;
1365
- readonly type?: MaybeReadonlyAtom<string>;
1366
- readonly values?: MaybeReadonlyAtom<string>;
1344
+ readonly accumulate?: MaybeReadAtom<SVGAccumulate>;
1345
+ readonly additive?: MaybeReadAtom<SVGAdditive>;
1346
+ readonly attributeName?: MaybeReadAtom<string>;
1347
+ readonly begin?: MaybeReadAtom<string>;
1348
+ readonly by?: MaybeReadAtom<string | number>;
1349
+ readonly calcMode?: MaybeReadAtom<SVGCalcMode>;
1350
+ readonly dur?: MaybeReadAtom<string | number>;
1351
+ readonly end?: MaybeReadAtom<string>;
1352
+ readonly fill?: MaybeReadAtom<SVGFillMode>;
1353
+ readonly from?: MaybeReadAtom<string | number>;
1354
+ readonly href?: MaybeReadAtom<string>;
1355
+ readonly keyPoints?: MaybeReadAtom<string>;
1356
+ readonly keySplines?: MaybeReadAtom<string>;
1357
+ readonly keyTimes?: MaybeReadAtom<string>;
1358
+ readonly max?: MaybeReadAtom<string>;
1359
+ readonly min?: MaybeReadAtom<string>;
1360
+ readonly repeatCount?: MaybeReadAtom<number | "indefinite">;
1361
+ readonly repeatDur?: MaybeReadAtom<string | number>;
1362
+ readonly requiredExtensions?: MaybeReadAtom<string>;
1363
+ readonly restart?: MaybeReadAtom<SVGRestart>;
1364
+ readonly systemLanguage?: MaybeReadAtom<string>;
1365
+ readonly to?: MaybeReadAtom<string | number>;
1366
+ readonly type?: MaybeReadAtom<string>;
1367
+ readonly values?: MaybeReadAtom<string>;
1367
1368
  }
1368
1369
  interface SVGCircleElementProps extends SVGGlobalProps {
1369
1370
  readonly [S_NODE_TYPE]?: SVGCircleElement;
1370
1371
  readonly children?: never;
1371
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
1372
- readonly "clip-rule"?: MaybeReadonlyAtom<SVGClipRule>;
1373
- readonly cursor?: MaybeReadonlyAtom<string>;
1374
- readonly cx?: MaybeReadonlyAtom<string | number>;
1375
- readonly cy?: MaybeReadonlyAtom<string | number>;
1376
- readonly fill?: MaybeReadonlyAtom<string>;
1377
- readonly "fill-opacity"?: MaybeReadonlyAtom<string | number>;
1378
- readonly "marker-end"?: MaybeReadonlyAtom<string>;
1379
- readonly "marker-mid"?: MaybeReadonlyAtom<string>;
1380
- readonly "marker-start"?: MaybeReadonlyAtom<string>;
1381
- readonly mask?: MaybeReadonlyAtom<string>;
1382
- readonly opacity?: MaybeReadonlyAtom<string | number>;
1383
- readonly "paint-order"?: MaybeReadonlyAtom<string>;
1384
- readonly pathLength?: MaybeReadonlyAtom<string | number>;
1385
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
1386
- readonly r?: MaybeReadonlyAtom<string | number>;
1387
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
1388
- readonly "shape-rendering"?: MaybeReadonlyAtom<SVGShapeRendering>;
1389
- readonly stroke?: MaybeReadonlyAtom<string>;
1390
- readonly "stroke-dasharray"?: MaybeReadonlyAtom<string>;
1391
- readonly "stroke-dashoffset"?: MaybeReadonlyAtom<string | number>;
1392
- readonly "stroke-opacity"?: MaybeReadonlyAtom<string | number>;
1393
- readonly "stroke-width"?: MaybeReadonlyAtom<string | number>;
1394
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
1395
- readonly "vector-effect"?: MaybeReadonlyAtom<SVGVectorEffect>;
1396
- readonly visibility?: MaybeReadonlyAtom<SVGVisibility>;
1372
+ readonly "clip-path"?: MaybeReadAtom<string>;
1373
+ readonly "clip-rule"?: MaybeReadAtom<SVGClipRule>;
1374
+ readonly cursor?: MaybeReadAtom<string>;
1375
+ readonly cx?: MaybeReadAtom<string | number>;
1376
+ readonly cy?: MaybeReadAtom<string | number>;
1377
+ readonly fill?: MaybeReadAtom<string>;
1378
+ readonly "fill-opacity"?: MaybeReadAtom<string | number>;
1379
+ readonly "marker-end"?: MaybeReadAtom<string>;
1380
+ readonly "marker-mid"?: MaybeReadAtom<string>;
1381
+ readonly "marker-start"?: MaybeReadAtom<string>;
1382
+ readonly mask?: MaybeReadAtom<string>;
1383
+ readonly opacity?: MaybeReadAtom<string | number>;
1384
+ readonly "paint-order"?: MaybeReadAtom<string>;
1385
+ readonly pathLength?: MaybeReadAtom<string | number>;
1386
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
1387
+ readonly r?: MaybeReadAtom<string | number>;
1388
+ readonly requiredExtensions?: MaybeReadAtom<string>;
1389
+ readonly "shape-rendering"?: MaybeReadAtom<SVGShapeRendering>;
1390
+ readonly stroke?: MaybeReadAtom<string>;
1391
+ readonly "stroke-dasharray"?: MaybeReadAtom<string>;
1392
+ readonly "stroke-dashoffset"?: MaybeReadAtom<string | number>;
1393
+ readonly "stroke-opacity"?: MaybeReadAtom<string | number>;
1394
+ readonly "stroke-width"?: MaybeReadAtom<string | number>;
1395
+ readonly systemLanguage?: MaybeReadAtom<string>;
1396
+ readonly "vector-effect"?: MaybeReadAtom<SVGVectorEffect>;
1397
+ readonly visibility?: MaybeReadAtom<SVGVisibility>;
1397
1398
  }
1398
1399
  interface SVGClipPathElementProps extends SVGGlobalProps {
1399
1400
  readonly [S_NODE_TYPE]?: SVGClipPathElement;
1400
1401
  readonly children?: JsxChildren;
1401
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
1402
- readonly clipPathUnits?: MaybeReadonlyAtom<SVGUnits>;
1403
- readonly mask?: MaybeReadonlyAtom<string>;
1404
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
1405
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
1406
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
1402
+ readonly "clip-path"?: MaybeReadAtom<string>;
1403
+ readonly clipPathUnits?: MaybeReadAtom<SVGUnits>;
1404
+ readonly mask?: MaybeReadAtom<string>;
1405
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
1406
+ readonly requiredExtensions?: MaybeReadAtom<string>;
1407
+ readonly systemLanguage?: MaybeReadAtom<string>;
1407
1408
  }
1408
1409
  interface SVGDefsElementProps extends SVGGlobalProps {
1409
1410
  readonly [S_NODE_TYPE]?: SVGDefsElement;
1410
1411
  readonly children?: JsxChildren;
1411
- readonly cursor?: MaybeReadonlyAtom<string>;
1412
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
1413
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
1414
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
1412
+ readonly cursor?: MaybeReadAtom<string>;
1413
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
1414
+ readonly requiredExtensions?: MaybeReadAtom<string>;
1415
+ readonly systemLanguage?: MaybeReadAtom<string>;
1415
1416
  }
1416
1417
  interface SVGDescElementProps extends SVGGlobalProps {
1417
1418
  readonly [S_NODE_TYPE]?: SVGDescElement;
@@ -1420,483 +1421,483 @@ interface SVGDescElementProps extends SVGGlobalProps {
1420
1421
  interface SVGEllipseElementProps extends SVGGlobalProps {
1421
1422
  readonly [S_NODE_TYPE]?: SVGEllipseElement;
1422
1423
  readonly children?: never;
1423
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
1424
- readonly "clip-rule"?: MaybeReadonlyAtom<SVGClipRule>;
1425
- readonly cursor?: MaybeReadonlyAtom<string>;
1426
- readonly cx?: MaybeReadonlyAtom<string | number>;
1427
- readonly cy?: MaybeReadonlyAtom<string | number>;
1428
- readonly fill?: MaybeReadonlyAtom<string>;
1429
- readonly "fill-opacity"?: MaybeReadonlyAtom<string | number>;
1430
- readonly "marker-end"?: MaybeReadonlyAtom<string>;
1431
- readonly "marker-mid"?: MaybeReadonlyAtom<string>;
1432
- readonly "marker-start"?: MaybeReadonlyAtom<string>;
1433
- readonly mask?: MaybeReadonlyAtom<string>;
1434
- readonly opacity?: MaybeReadonlyAtom<string | number>;
1435
- readonly "paint-order"?: MaybeReadonlyAtom<string>;
1436
- readonly pathLength?: MaybeReadonlyAtom<string | number>;
1437
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
1438
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
1439
- readonly rx?: MaybeReadonlyAtom<string | number>;
1440
- readonly ry?: MaybeReadonlyAtom<string | number>;
1441
- readonly "shape-rendering"?: MaybeReadonlyAtom<SVGShapeRendering>;
1442
- readonly stroke?: MaybeReadonlyAtom<string>;
1443
- readonly "stroke-dasharray"?: MaybeReadonlyAtom<string>;
1444
- readonly "stroke-dashoffset"?: MaybeReadonlyAtom<string | number>;
1445
- readonly "stroke-opacity"?: MaybeReadonlyAtom<string | number>;
1446
- readonly "stroke-width"?: MaybeReadonlyAtom<string | number>;
1447
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
1448
- readonly "vector-effect"?: MaybeReadonlyAtom<SVGVectorEffect>;
1449
- readonly visibility?: MaybeReadonlyAtom<SVGVisibility>;
1424
+ readonly "clip-path"?: MaybeReadAtom<string>;
1425
+ readonly "clip-rule"?: MaybeReadAtom<SVGClipRule>;
1426
+ readonly cursor?: MaybeReadAtom<string>;
1427
+ readonly cx?: MaybeReadAtom<string | number>;
1428
+ readonly cy?: MaybeReadAtom<string | number>;
1429
+ readonly fill?: MaybeReadAtom<string>;
1430
+ readonly "fill-opacity"?: MaybeReadAtom<string | number>;
1431
+ readonly "marker-end"?: MaybeReadAtom<string>;
1432
+ readonly "marker-mid"?: MaybeReadAtom<string>;
1433
+ readonly "marker-start"?: MaybeReadAtom<string>;
1434
+ readonly mask?: MaybeReadAtom<string>;
1435
+ readonly opacity?: MaybeReadAtom<string | number>;
1436
+ readonly "paint-order"?: MaybeReadAtom<string>;
1437
+ readonly pathLength?: MaybeReadAtom<string | number>;
1438
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
1439
+ readonly requiredExtensions?: MaybeReadAtom<string>;
1440
+ readonly rx?: MaybeReadAtom<string | number>;
1441
+ readonly ry?: MaybeReadAtom<string | number>;
1442
+ readonly "shape-rendering"?: MaybeReadAtom<SVGShapeRendering>;
1443
+ readonly stroke?: MaybeReadAtom<string>;
1444
+ readonly "stroke-dasharray"?: MaybeReadAtom<string>;
1445
+ readonly "stroke-dashoffset"?: MaybeReadAtom<string | number>;
1446
+ readonly "stroke-opacity"?: MaybeReadAtom<string | number>;
1447
+ readonly "stroke-width"?: MaybeReadAtom<string | number>;
1448
+ readonly systemLanguage?: MaybeReadAtom<string>;
1449
+ readonly "vector-effect"?: MaybeReadAtom<SVGVectorEffect>;
1450
+ readonly visibility?: MaybeReadAtom<SVGVisibility>;
1450
1451
  }
1451
1452
  interface SVGFEBlendElementProps extends SVGGlobalProps {
1452
1453
  readonly [S_NODE_TYPE]?: SVGFEBlendElement;
1453
1454
  readonly children?: JsxChildren;
1454
- readonly "color-interpolation-filters"?: MaybeReadonlyAtom<SVGColorInterpolationFilters>;
1455
- readonly height?: MaybeReadonlyAtom<string | number>;
1456
- readonly in?: MaybeReadonlyAtom<string>;
1457
- readonly in2?: MaybeReadonlyAtom<string>;
1458
- readonly mode?: MaybeReadonlyAtom<string>;
1459
- readonly result?: MaybeReadonlyAtom<string>;
1460
- readonly width?: MaybeReadonlyAtom<string | number>;
1461
- readonly x?: MaybeReadonlyAtom<string | number>;
1462
- readonly y?: MaybeReadonlyAtom<string | number>;
1455
+ readonly "color-interpolation-filters"?: MaybeReadAtom<SVGColorInterpolationFilters>;
1456
+ readonly height?: MaybeReadAtom<string | number>;
1457
+ readonly in?: MaybeReadAtom<string>;
1458
+ readonly in2?: MaybeReadAtom<string>;
1459
+ readonly mode?: MaybeReadAtom<string>;
1460
+ readonly result?: MaybeReadAtom<string>;
1461
+ readonly width?: MaybeReadAtom<string | number>;
1462
+ readonly x?: MaybeReadAtom<string | number>;
1463
+ readonly y?: MaybeReadAtom<string | number>;
1463
1464
  }
1464
1465
  interface SVGFEColorMatrixElementProps extends SVGGlobalProps {
1465
1466
  readonly [S_NODE_TYPE]?: SVGFEColorMatrixElement;
1466
1467
  readonly children?: JsxChildren;
1467
- readonly "color-interpolation-filters"?: MaybeReadonlyAtom<SVGColorInterpolationFilters>;
1468
- readonly height?: MaybeReadonlyAtom<string | number>;
1469
- readonly in?: MaybeReadonlyAtom<string>;
1470
- readonly result?: MaybeReadonlyAtom<string>;
1471
- readonly type?: MaybeReadonlyAtom<string>;
1472
- readonly values?: MaybeReadonlyAtom<string>;
1473
- readonly width?: MaybeReadonlyAtom<string | number>;
1474
- readonly x?: MaybeReadonlyAtom<string | number>;
1475
- readonly y?: MaybeReadonlyAtom<string | number>;
1468
+ readonly "color-interpolation-filters"?: MaybeReadAtom<SVGColorInterpolationFilters>;
1469
+ readonly height?: MaybeReadAtom<string | number>;
1470
+ readonly in?: MaybeReadAtom<string>;
1471
+ readonly result?: MaybeReadAtom<string>;
1472
+ readonly type?: MaybeReadAtom<string>;
1473
+ readonly values?: MaybeReadAtom<string>;
1474
+ readonly width?: MaybeReadAtom<string | number>;
1475
+ readonly x?: MaybeReadAtom<string | number>;
1476
+ readonly y?: MaybeReadAtom<string | number>;
1476
1477
  }
1477
1478
  interface SVGFEComponentTransferElementProps extends SVGGlobalProps {
1478
1479
  readonly [S_NODE_TYPE]?: SVGFEComponentTransferElement;
1479
1480
  readonly children?: JsxChildren;
1480
- readonly "color-interpolation-filters"?: MaybeReadonlyAtom<SVGColorInterpolationFilters>;
1481
- readonly height?: MaybeReadonlyAtom<string | number>;
1482
- readonly in?: MaybeReadonlyAtom<string>;
1483
- readonly result?: MaybeReadonlyAtom<string>;
1484
- readonly width?: MaybeReadonlyAtom<string | number>;
1485
- readonly x?: MaybeReadonlyAtom<string | number>;
1486
- readonly y?: MaybeReadonlyAtom<string | number>;
1481
+ readonly "color-interpolation-filters"?: MaybeReadAtom<SVGColorInterpolationFilters>;
1482
+ readonly height?: MaybeReadAtom<string | number>;
1483
+ readonly in?: MaybeReadAtom<string>;
1484
+ readonly result?: MaybeReadAtom<string>;
1485
+ readonly width?: MaybeReadAtom<string | number>;
1486
+ readonly x?: MaybeReadAtom<string | number>;
1487
+ readonly y?: MaybeReadAtom<string | number>;
1487
1488
  }
1488
1489
  interface SVGFECompositeElementProps extends SVGGlobalProps {
1489
1490
  readonly [S_NODE_TYPE]?: SVGFECompositeElement;
1490
1491
  readonly children?: JsxChildren;
1491
- readonly "color-interpolation-filters"?: MaybeReadonlyAtom<SVGColorInterpolationFilters>;
1492
- readonly height?: MaybeReadonlyAtom<string | number>;
1493
- readonly in?: MaybeReadonlyAtom<string>;
1494
- readonly in2?: MaybeReadonlyAtom<string>;
1495
- readonly k1?: MaybeReadonlyAtom<string | number>;
1496
- readonly k2?: MaybeReadonlyAtom<string | number>;
1497
- readonly k3?: MaybeReadonlyAtom<string | number>;
1498
- readonly k4?: MaybeReadonlyAtom<string | number>;
1499
- readonly operator?: MaybeReadonlyAtom<"in" | "over" | "out" | "atop" | "xor" | "lighter" | "arithmetic">;
1500
- readonly result?: MaybeReadonlyAtom<string>;
1501
- readonly width?: MaybeReadonlyAtom<string | number>;
1502
- readonly x?: MaybeReadonlyAtom<string | number>;
1503
- readonly y?: MaybeReadonlyAtom<string | number>;
1492
+ readonly "color-interpolation-filters"?: MaybeReadAtom<SVGColorInterpolationFilters>;
1493
+ readonly height?: MaybeReadAtom<string | number>;
1494
+ readonly in?: MaybeReadAtom<string>;
1495
+ readonly in2?: MaybeReadAtom<string>;
1496
+ readonly k1?: MaybeReadAtom<string | number>;
1497
+ readonly k2?: MaybeReadAtom<string | number>;
1498
+ readonly k3?: MaybeReadAtom<string | number>;
1499
+ readonly k4?: MaybeReadAtom<string | number>;
1500
+ readonly operator?: MaybeReadAtom<"in" | "over" | "out" | "atop" | "xor" | "lighter" | "arithmetic">;
1501
+ readonly result?: MaybeReadAtom<string>;
1502
+ readonly width?: MaybeReadAtom<string | number>;
1503
+ readonly x?: MaybeReadAtom<string | number>;
1504
+ readonly y?: MaybeReadAtom<string | number>;
1504
1505
  }
1505
1506
  interface SVGFEConvolveMatrixElementProps extends SVGGlobalProps {
1506
1507
  readonly [S_NODE_TYPE]?: SVGFEConvolveMatrixElement;
1507
1508
  readonly children?: JsxChildren;
1508
- readonly bias?: MaybeReadonlyAtom<string | number>;
1509
- readonly "color-interpolation-filters"?: MaybeReadonlyAtom<SVGColorInterpolationFilters>;
1510
- readonly divisor?: MaybeReadonlyAtom<string | number>;
1511
- readonly edgeMode?: MaybeReadonlyAtom<SVGEdgeMode>;
1512
- readonly height?: MaybeReadonlyAtom<string | number>;
1513
- readonly in?: MaybeReadonlyAtom<string>;
1514
- readonly kernelMatrix?: MaybeReadonlyAtom<string>;
1515
- readonly kernelUnitLength?: MaybeReadonlyAtom<string | number>;
1516
- readonly order?: MaybeReadonlyAtom<string | number>;
1517
- readonly preserveAlpha?: MaybeReadonlyAtom<string | boolean>;
1518
- readonly result?: MaybeReadonlyAtom<string>;
1519
- readonly targetX?: MaybeReadonlyAtom<string | number>;
1520
- readonly targetY?: MaybeReadonlyAtom<string | number>;
1521
- readonly width?: MaybeReadonlyAtom<string | number>;
1522
- readonly x?: MaybeReadonlyAtom<string | number>;
1523
- readonly y?: MaybeReadonlyAtom<string | number>;
1509
+ readonly bias?: MaybeReadAtom<string | number>;
1510
+ readonly "color-interpolation-filters"?: MaybeReadAtom<SVGColorInterpolationFilters>;
1511
+ readonly divisor?: MaybeReadAtom<string | number>;
1512
+ readonly edgeMode?: MaybeReadAtom<SVGEdgeMode>;
1513
+ readonly height?: MaybeReadAtom<string | number>;
1514
+ readonly in?: MaybeReadAtom<string>;
1515
+ readonly kernelMatrix?: MaybeReadAtom<string>;
1516
+ readonly kernelUnitLength?: MaybeReadAtom<string | number>;
1517
+ readonly order?: MaybeReadAtom<string | number>;
1518
+ readonly preserveAlpha?: MaybeReadAtom<string | boolean>;
1519
+ readonly result?: MaybeReadAtom<string>;
1520
+ readonly targetX?: MaybeReadAtom<string | number>;
1521
+ readonly targetY?: MaybeReadAtom<string | number>;
1522
+ readonly width?: MaybeReadAtom<string | number>;
1523
+ readonly x?: MaybeReadAtom<string | number>;
1524
+ readonly y?: MaybeReadAtom<string | number>;
1524
1525
  }
1525
1526
  interface SVGFEDiffuseLightingElementProps extends SVGGlobalProps {
1526
1527
  readonly [S_NODE_TYPE]?: SVGFEDiffuseLightingElement;
1527
1528
  readonly children?: JsxChildren;
1528
- readonly "color-interpolation-filters"?: MaybeReadonlyAtom<SVGColorInterpolationFilters>;
1529
- readonly diffuseConstant?: MaybeReadonlyAtom<string | number>;
1530
- readonly height?: MaybeReadonlyAtom<string | number>;
1531
- readonly in?: MaybeReadonlyAtom<string>;
1532
- readonly kernelUnitLength?: MaybeReadonlyAtom<string | number>;
1533
- readonly "lighting-color"?: MaybeReadonlyAtom<string>;
1534
- readonly result?: MaybeReadonlyAtom<string>;
1535
- readonly surfaceScale?: MaybeReadonlyAtom<string | number>;
1536
- readonly width?: MaybeReadonlyAtom<string | number>;
1537
- readonly x?: MaybeReadonlyAtom<string | number>;
1538
- readonly y?: MaybeReadonlyAtom<string | number>;
1529
+ readonly "color-interpolation-filters"?: MaybeReadAtom<SVGColorInterpolationFilters>;
1530
+ readonly diffuseConstant?: MaybeReadAtom<string | number>;
1531
+ readonly height?: MaybeReadAtom<string | number>;
1532
+ readonly in?: MaybeReadAtom<string>;
1533
+ readonly kernelUnitLength?: MaybeReadAtom<string | number>;
1534
+ readonly "lighting-color"?: MaybeReadAtom<string>;
1535
+ readonly result?: MaybeReadAtom<string>;
1536
+ readonly surfaceScale?: MaybeReadAtom<string | number>;
1537
+ readonly width?: MaybeReadAtom<string | number>;
1538
+ readonly x?: MaybeReadAtom<string | number>;
1539
+ readonly y?: MaybeReadAtom<string | number>;
1539
1540
  }
1540
1541
  interface SVGFEDisplacementMapElementProps extends SVGGlobalProps {
1541
1542
  readonly [S_NODE_TYPE]?: SVGFEDisplacementMapElement;
1542
1543
  readonly children?: JsxChildren;
1543
- readonly "color-interpolation-filters"?: MaybeReadonlyAtom<SVGColorInterpolationFilters>;
1544
- readonly height?: MaybeReadonlyAtom<string | number>;
1545
- readonly in?: MaybeReadonlyAtom<string>;
1546
- readonly in2?: MaybeReadonlyAtom<string>;
1547
- readonly result?: MaybeReadonlyAtom<string>;
1548
- readonly scale?: MaybeReadonlyAtom<string | number>;
1549
- readonly width?: MaybeReadonlyAtom<string | number>;
1550
- readonly x?: MaybeReadonlyAtom<string | number>;
1551
- readonly xChannelSelector?: MaybeReadonlyAtom<SVGColorChannel>;
1552
- readonly y?: MaybeReadonlyAtom<string | number>;
1553
- readonly yChannelSelector?: MaybeReadonlyAtom<SVGColorChannel>;
1544
+ readonly "color-interpolation-filters"?: MaybeReadAtom<SVGColorInterpolationFilters>;
1545
+ readonly height?: MaybeReadAtom<string | number>;
1546
+ readonly in?: MaybeReadAtom<string>;
1547
+ readonly in2?: MaybeReadAtom<string>;
1548
+ readonly result?: MaybeReadAtom<string>;
1549
+ readonly scale?: MaybeReadAtom<string | number>;
1550
+ readonly width?: MaybeReadAtom<string | number>;
1551
+ readonly x?: MaybeReadAtom<string | number>;
1552
+ readonly xChannelSelector?: MaybeReadAtom<SVGColorChannel>;
1553
+ readonly y?: MaybeReadAtom<string | number>;
1554
+ readonly yChannelSelector?: MaybeReadAtom<SVGColorChannel>;
1554
1555
  }
1555
1556
  interface SVGFEDistantLightElementProps extends SVGGlobalProps {
1556
1557
  readonly [S_NODE_TYPE]?: SVGFEDistantLightElement;
1557
1558
  readonly children?: JsxChildren;
1558
- readonly azimuth?: MaybeReadonlyAtom<string | number>;
1559
- readonly elevation?: MaybeReadonlyAtom<string | number>;
1559
+ readonly azimuth?: MaybeReadAtom<string | number>;
1560
+ readonly elevation?: MaybeReadAtom<string | number>;
1560
1561
  }
1561
1562
  interface SVGFEDropShadowElementProps extends SVGGlobalProps {
1562
1563
  readonly [S_NODE_TYPE]?: SVGFEDropShadowElement;
1563
1564
  readonly children?: JsxChildren;
1564
- readonly "color-interpolation-filters"?: MaybeReadonlyAtom<SVGColorInterpolationFilters>;
1565
- readonly dx?: MaybeReadonlyAtom<string | number>;
1566
- readonly dy?: MaybeReadonlyAtom<string | number>;
1567
- readonly "flood-color"?: MaybeReadonlyAtom<string>;
1568
- readonly "flood-opacity"?: MaybeReadonlyAtom<string | number>;
1569
- readonly height?: MaybeReadonlyAtom<string | number>;
1570
- readonly in?: MaybeReadonlyAtom<string>;
1571
- readonly result?: MaybeReadonlyAtom<string>;
1572
- readonly stdDeviation?: MaybeReadonlyAtom<string | number>;
1573
- readonly width?: MaybeReadonlyAtom<string | number>;
1574
- readonly x?: MaybeReadonlyAtom<string | number>;
1575
- readonly y?: MaybeReadonlyAtom<string | number>;
1565
+ readonly "color-interpolation-filters"?: MaybeReadAtom<SVGColorInterpolationFilters>;
1566
+ readonly dx?: MaybeReadAtom<string | number>;
1567
+ readonly dy?: MaybeReadAtom<string | number>;
1568
+ readonly "flood-color"?: MaybeReadAtom<string>;
1569
+ readonly "flood-opacity"?: MaybeReadAtom<string | number>;
1570
+ readonly height?: MaybeReadAtom<string | number>;
1571
+ readonly in?: MaybeReadAtom<string>;
1572
+ readonly result?: MaybeReadAtom<string>;
1573
+ readonly stdDeviation?: MaybeReadAtom<string | number>;
1574
+ readonly width?: MaybeReadAtom<string | number>;
1575
+ readonly x?: MaybeReadAtom<string | number>;
1576
+ readonly y?: MaybeReadAtom<string | number>;
1576
1577
  }
1577
1578
  interface SVGFEFloodElementProps extends SVGGlobalProps {
1578
1579
  readonly [S_NODE_TYPE]?: SVGFEFloodElement;
1579
1580
  readonly children?: JsxChildren;
1580
- readonly "color-interpolation-filters"?: MaybeReadonlyAtom<SVGColorInterpolationFilters>;
1581
- readonly "flood-color"?: MaybeReadonlyAtom<string>;
1582
- readonly "flood-opacity"?: MaybeReadonlyAtom<string | number>;
1583
- readonly height?: MaybeReadonlyAtom<string | number>;
1584
- readonly result?: MaybeReadonlyAtom<string>;
1585
- readonly width?: MaybeReadonlyAtom<string | number>;
1586
- readonly x?: MaybeReadonlyAtom<string | number>;
1587
- readonly y?: MaybeReadonlyAtom<string | number>;
1581
+ readonly "color-interpolation-filters"?: MaybeReadAtom<SVGColorInterpolationFilters>;
1582
+ readonly "flood-color"?: MaybeReadAtom<string>;
1583
+ readonly "flood-opacity"?: MaybeReadAtom<string | number>;
1584
+ readonly height?: MaybeReadAtom<string | number>;
1585
+ readonly result?: MaybeReadAtom<string>;
1586
+ readonly width?: MaybeReadAtom<string | number>;
1587
+ readonly x?: MaybeReadAtom<string | number>;
1588
+ readonly y?: MaybeReadAtom<string | number>;
1588
1589
  }
1589
1590
  interface SVGFEFuncAElementProps extends SVGGlobalProps {
1590
1591
  readonly [S_NODE_TYPE]?: SVGFEFuncAElement;
1591
1592
  readonly children?: JsxChildren;
1592
- readonly amplitude?: MaybeReadonlyAtom<string | number>;
1593
- readonly exponent?: MaybeReadonlyAtom<string | number>;
1594
- readonly intercept?: MaybeReadonlyAtom<string | number>;
1595
- readonly slope?: MaybeReadonlyAtom<string | number>;
1596
- readonly tableValues?: MaybeReadonlyAtom<string>;
1597
- readonly type?: MaybeReadonlyAtom<string>;
1598
- readonly x?: MaybeReadonlyAtom<string | number>;
1599
- readonly y?: MaybeReadonlyAtom<string | number>;
1593
+ readonly amplitude?: MaybeReadAtom<string | number>;
1594
+ readonly exponent?: MaybeReadAtom<string | number>;
1595
+ readonly intercept?: MaybeReadAtom<string | number>;
1596
+ readonly slope?: MaybeReadAtom<string | number>;
1597
+ readonly tableValues?: MaybeReadAtom<string>;
1598
+ readonly type?: MaybeReadAtom<string>;
1599
+ readonly x?: MaybeReadAtom<string | number>;
1600
+ readonly y?: MaybeReadAtom<string | number>;
1600
1601
  }
1601
1602
  interface SVGFEFuncBElementProps extends SVGGlobalProps {
1602
1603
  readonly [S_NODE_TYPE]?: SVGFEFuncBElement;
1603
1604
  readonly children?: JsxChildren;
1604
- readonly amplitude?: MaybeReadonlyAtom<string | number>;
1605
- readonly exponent?: MaybeReadonlyAtom<string | number>;
1606
- readonly intercept?: MaybeReadonlyAtom<string | number>;
1607
- readonly slope?: MaybeReadonlyAtom<string | number>;
1608
- readonly tableValues?: MaybeReadonlyAtom<string>;
1609
- readonly type?: MaybeReadonlyAtom<string>;
1610
- readonly x?: MaybeReadonlyAtom<string | number>;
1611
- readonly y?: MaybeReadonlyAtom<string | number>;
1605
+ readonly amplitude?: MaybeReadAtom<string | number>;
1606
+ readonly exponent?: MaybeReadAtom<string | number>;
1607
+ readonly intercept?: MaybeReadAtom<string | number>;
1608
+ readonly slope?: MaybeReadAtom<string | number>;
1609
+ readonly tableValues?: MaybeReadAtom<string>;
1610
+ readonly type?: MaybeReadAtom<string>;
1611
+ readonly x?: MaybeReadAtom<string | number>;
1612
+ readonly y?: MaybeReadAtom<string | number>;
1612
1613
  }
1613
1614
  interface SVGFEFuncGElementProps extends SVGGlobalProps {
1614
1615
  readonly [S_NODE_TYPE]?: SVGFEFuncGElement;
1615
1616
  readonly children?: JsxChildren;
1616
- readonly amplitude?: MaybeReadonlyAtom<string | number>;
1617
- readonly exponent?: MaybeReadonlyAtom<string | number>;
1618
- readonly intercept?: MaybeReadonlyAtom<string | number>;
1619
- readonly slope?: MaybeReadonlyAtom<string | number>;
1620
- readonly tableValues?: MaybeReadonlyAtom<string>;
1621
- readonly type?: MaybeReadonlyAtom<string>;
1622
- readonly x?: MaybeReadonlyAtom<string | number>;
1623
- readonly y?: MaybeReadonlyAtom<string | number>;
1617
+ readonly amplitude?: MaybeReadAtom<string | number>;
1618
+ readonly exponent?: MaybeReadAtom<string | number>;
1619
+ readonly intercept?: MaybeReadAtom<string | number>;
1620
+ readonly slope?: MaybeReadAtom<string | number>;
1621
+ readonly tableValues?: MaybeReadAtom<string>;
1622
+ readonly type?: MaybeReadAtom<string>;
1623
+ readonly x?: MaybeReadAtom<string | number>;
1624
+ readonly y?: MaybeReadAtom<string | number>;
1624
1625
  }
1625
1626
  interface SVGFEFuncRElementProps extends SVGGlobalProps {
1626
1627
  readonly [S_NODE_TYPE]?: SVGFEFuncRElement;
1627
1628
  readonly children?: JsxChildren;
1628
- readonly amplitude?: MaybeReadonlyAtom<string | number>;
1629
- readonly exponent?: MaybeReadonlyAtom<string | number>;
1630
- readonly intercept?: MaybeReadonlyAtom<string | number>;
1631
- readonly slope?: MaybeReadonlyAtom<string | number>;
1632
- readonly tableValues?: MaybeReadonlyAtom<string>;
1633
- readonly type?: MaybeReadonlyAtom<string>;
1634
- readonly x?: MaybeReadonlyAtom<string | number>;
1635
- readonly y?: MaybeReadonlyAtom<string | number>;
1629
+ readonly amplitude?: MaybeReadAtom<string | number>;
1630
+ readonly exponent?: MaybeReadAtom<string | number>;
1631
+ readonly intercept?: MaybeReadAtom<string | number>;
1632
+ readonly slope?: MaybeReadAtom<string | number>;
1633
+ readonly tableValues?: MaybeReadAtom<string>;
1634
+ readonly type?: MaybeReadAtom<string>;
1635
+ readonly x?: MaybeReadAtom<string | number>;
1636
+ readonly y?: MaybeReadAtom<string | number>;
1636
1637
  }
1637
1638
  interface SVGFEGaussianBlurElementProps extends SVGGlobalProps {
1638
1639
  readonly [S_NODE_TYPE]?: SVGFEGaussianBlurElement;
1639
1640
  readonly children?: JsxChildren;
1640
- readonly "color-interpolation-filters"?: MaybeReadonlyAtom<SVGColorInterpolationFilters>;
1641
- readonly edgeMode?: MaybeReadonlyAtom<SVGEdgeMode>;
1642
- readonly height?: MaybeReadonlyAtom<string | number>;
1643
- readonly in?: MaybeReadonlyAtom<string>;
1644
- readonly result?: MaybeReadonlyAtom<string>;
1645
- readonly stdDeviation?: MaybeReadonlyAtom<string | number>;
1646
- readonly width?: MaybeReadonlyAtom<string | number>;
1647
- readonly x?: MaybeReadonlyAtom<string | number>;
1648
- readonly y?: MaybeReadonlyAtom<string | number>;
1641
+ readonly "color-interpolation-filters"?: MaybeReadAtom<SVGColorInterpolationFilters>;
1642
+ readonly edgeMode?: MaybeReadAtom<SVGEdgeMode>;
1643
+ readonly height?: MaybeReadAtom<string | number>;
1644
+ readonly in?: MaybeReadAtom<string>;
1645
+ readonly result?: MaybeReadAtom<string>;
1646
+ readonly stdDeviation?: MaybeReadAtom<string | number>;
1647
+ readonly width?: MaybeReadAtom<string | number>;
1648
+ readonly x?: MaybeReadAtom<string | number>;
1649
+ readonly y?: MaybeReadAtom<string | number>;
1649
1650
  }
1650
1651
  interface SVGFEImageElementProps extends SVGGlobalProps {
1651
1652
  readonly [S_NODE_TYPE]?: SVGFEImageElement;
1652
1653
  readonly children?: JsxChildren;
1653
- readonly "color-interpolation-filters"?: MaybeReadonlyAtom<SVGColorInterpolationFilters>;
1654
- readonly height?: MaybeReadonlyAtom<string | number>;
1655
- readonly href?: MaybeReadonlyAtom<string>;
1656
- readonly preserveAspectRatio?: MaybeReadonlyAtom<string>;
1657
- readonly result?: MaybeReadonlyAtom<string>;
1658
- readonly width?: MaybeReadonlyAtom<string | number>;
1659
- readonly x?: MaybeReadonlyAtom<string | number>;
1660
- readonly y?: MaybeReadonlyAtom<string | number>;
1654
+ readonly "color-interpolation-filters"?: MaybeReadAtom<SVGColorInterpolationFilters>;
1655
+ readonly height?: MaybeReadAtom<string | number>;
1656
+ readonly href?: MaybeReadAtom<string>;
1657
+ readonly preserveAspectRatio?: MaybeReadAtom<string>;
1658
+ readonly result?: MaybeReadAtom<string>;
1659
+ readonly width?: MaybeReadAtom<string | number>;
1660
+ readonly x?: MaybeReadAtom<string | number>;
1661
+ readonly y?: MaybeReadAtom<string | number>;
1661
1662
  }
1662
1663
  interface SVGFEMergeElementProps extends SVGGlobalProps {
1663
1664
  readonly [S_NODE_TYPE]?: SVGFEMergeElement;
1664
1665
  readonly children?: JsxChildren;
1665
- readonly "color-interpolation-filters"?: MaybeReadonlyAtom<SVGColorInterpolationFilters>;
1666
- readonly height?: MaybeReadonlyAtom<string | number>;
1667
- readonly result?: MaybeReadonlyAtom<string>;
1668
- readonly width?: MaybeReadonlyAtom<string | number>;
1669
- readonly x?: MaybeReadonlyAtom<string | number>;
1670
- readonly y?: MaybeReadonlyAtom<string | number>;
1666
+ readonly "color-interpolation-filters"?: MaybeReadAtom<SVGColorInterpolationFilters>;
1667
+ readonly height?: MaybeReadAtom<string | number>;
1668
+ readonly result?: MaybeReadAtom<string>;
1669
+ readonly width?: MaybeReadAtom<string | number>;
1670
+ readonly x?: MaybeReadAtom<string | number>;
1671
+ readonly y?: MaybeReadAtom<string | number>;
1671
1672
  }
1672
1673
  interface SVGFEMergeNodeElementProps extends SVGGlobalProps {
1673
1674
  readonly [S_NODE_TYPE]?: SVGFEMergeNodeElement;
1674
1675
  readonly children?: JsxChildren;
1675
- readonly in?: MaybeReadonlyAtom<string>;
1676
- readonly x?: MaybeReadonlyAtom<string | number>;
1677
- readonly y?: MaybeReadonlyAtom<string | number>;
1676
+ readonly in?: MaybeReadAtom<string>;
1677
+ readonly x?: MaybeReadAtom<string | number>;
1678
+ readonly y?: MaybeReadAtom<string | number>;
1678
1679
  }
1679
1680
  interface SVGFEMorphologyElementProps extends SVGGlobalProps {
1680
1681
  readonly [S_NODE_TYPE]?: SVGFEMorphologyElement;
1681
1682
  readonly children?: JsxChildren;
1682
- readonly height?: MaybeReadonlyAtom<string | number>;
1683
- readonly in?: MaybeReadonlyAtom<string>;
1684
- readonly operator?: MaybeReadonlyAtom<"erode" | "dilate">;
1685
- readonly radius?: MaybeReadonlyAtom<string | number>;
1686
- readonly result?: MaybeReadonlyAtom<string>;
1687
- readonly width?: MaybeReadonlyAtom<string | number>;
1688
- readonly x?: MaybeReadonlyAtom<string | number>;
1689
- readonly y?: MaybeReadonlyAtom<string | number>;
1683
+ readonly height?: MaybeReadAtom<string | number>;
1684
+ readonly in?: MaybeReadAtom<string>;
1685
+ readonly operator?: MaybeReadAtom<"erode" | "dilate">;
1686
+ readonly radius?: MaybeReadAtom<string | number>;
1687
+ readonly result?: MaybeReadAtom<string>;
1688
+ readonly width?: MaybeReadAtom<string | number>;
1689
+ readonly x?: MaybeReadAtom<string | number>;
1690
+ readonly y?: MaybeReadAtom<string | number>;
1690
1691
  }
1691
1692
  interface SVGFEOffsetElementProps extends SVGGlobalProps {
1692
1693
  readonly [S_NODE_TYPE]?: SVGFEOffsetElement;
1693
1694
  readonly children?: JsxChildren;
1694
- readonly "color-interpolation-filters"?: MaybeReadonlyAtom<SVGColorInterpolationFilters>;
1695
- readonly dx?: MaybeReadonlyAtom<string | number>;
1696
- readonly dy?: MaybeReadonlyAtom<string | number>;
1697
- readonly height?: MaybeReadonlyAtom<string | number>;
1698
- readonly in?: MaybeReadonlyAtom<string>;
1699
- readonly result?: MaybeReadonlyAtom<string>;
1700
- readonly width?: MaybeReadonlyAtom<string | number>;
1701
- readonly x?: MaybeReadonlyAtom<string | number>;
1702
- readonly y?: MaybeReadonlyAtom<string | number>;
1695
+ readonly "color-interpolation-filters"?: MaybeReadAtom<SVGColorInterpolationFilters>;
1696
+ readonly dx?: MaybeReadAtom<string | number>;
1697
+ readonly dy?: MaybeReadAtom<string | number>;
1698
+ readonly height?: MaybeReadAtom<string | number>;
1699
+ readonly in?: MaybeReadAtom<string>;
1700
+ readonly result?: MaybeReadAtom<string>;
1701
+ readonly width?: MaybeReadAtom<string | number>;
1702
+ readonly x?: MaybeReadAtom<string | number>;
1703
+ readonly y?: MaybeReadAtom<string | number>;
1703
1704
  }
1704
1705
  interface SVGFEPointLightElementProps extends SVGGlobalProps {
1705
1706
  readonly [S_NODE_TYPE]?: SVGFEPointLightElement;
1706
1707
  readonly children?: JsxChildren;
1707
- readonly x?: MaybeReadonlyAtom<string | number>;
1708
- readonly y?: MaybeReadonlyAtom<string | number>;
1709
- readonly z?: MaybeReadonlyAtom<string | number>;
1708
+ readonly x?: MaybeReadAtom<string | number>;
1709
+ readonly y?: MaybeReadAtom<string | number>;
1710
+ readonly z?: MaybeReadAtom<string | number>;
1710
1711
  }
1711
1712
  interface SVGFESpecularLightingElementProps extends SVGGlobalProps {
1712
1713
  readonly [S_NODE_TYPE]?: SVGFESpecularLightingElement;
1713
1714
  readonly children?: JsxChildren;
1714
- readonly "color-interpolation-filters"?: MaybeReadonlyAtom<SVGColorInterpolationFilters>;
1715
- readonly height?: MaybeReadonlyAtom<string | number>;
1716
- readonly in?: MaybeReadonlyAtom<string>;
1717
- readonly kernelUnitLength?: MaybeReadonlyAtom<string | number>;
1718
- readonly "lighting-color"?: MaybeReadonlyAtom<string>;
1719
- readonly result?: MaybeReadonlyAtom<string>;
1720
- readonly specularConstant?: MaybeReadonlyAtom<string | number>;
1721
- readonly specularExponent?: MaybeReadonlyAtom<string | number>;
1722
- readonly surfaceScale?: MaybeReadonlyAtom<string | number>;
1723
- readonly width?: MaybeReadonlyAtom<string | number>;
1724
- readonly x?: MaybeReadonlyAtom<string | number>;
1725
- readonly y?: MaybeReadonlyAtom<string | number>;
1715
+ readonly "color-interpolation-filters"?: MaybeReadAtom<SVGColorInterpolationFilters>;
1716
+ readonly height?: MaybeReadAtom<string | number>;
1717
+ readonly in?: MaybeReadAtom<string>;
1718
+ readonly kernelUnitLength?: MaybeReadAtom<string | number>;
1719
+ readonly "lighting-color"?: MaybeReadAtom<string>;
1720
+ readonly result?: MaybeReadAtom<string>;
1721
+ readonly specularConstant?: MaybeReadAtom<string | number>;
1722
+ readonly specularExponent?: MaybeReadAtom<string | number>;
1723
+ readonly surfaceScale?: MaybeReadAtom<string | number>;
1724
+ readonly width?: MaybeReadAtom<string | number>;
1725
+ readonly x?: MaybeReadAtom<string | number>;
1726
+ readonly y?: MaybeReadAtom<string | number>;
1726
1727
  }
1727
1728
  interface SVGFESpotLightElementProps extends SVGGlobalProps {
1728
1729
  readonly [S_NODE_TYPE]?: SVGFESpotLightElement;
1729
1730
  readonly children?: JsxChildren;
1730
- readonly "color-interpolation-filters"?: MaybeReadonlyAtom<SVGColorInterpolationFilters>;
1731
- readonly limitingConeAngle?: MaybeReadonlyAtom<string | number>;
1732
- readonly pointsAtX?: MaybeReadonlyAtom<string | number>;
1733
- readonly pointsAtY?: MaybeReadonlyAtom<string | number>;
1734
- readonly pointsAtZ?: MaybeReadonlyAtom<string | number>;
1735
- readonly specularExponent?: MaybeReadonlyAtom<string | number>;
1736
- readonly x?: MaybeReadonlyAtom<string | number>;
1737
- readonly y?: MaybeReadonlyAtom<string | number>;
1738
- readonly z?: MaybeReadonlyAtom<string | number>;
1731
+ readonly "color-interpolation-filters"?: MaybeReadAtom<SVGColorInterpolationFilters>;
1732
+ readonly limitingConeAngle?: MaybeReadAtom<string | number>;
1733
+ readonly pointsAtX?: MaybeReadAtom<string | number>;
1734
+ readonly pointsAtY?: MaybeReadAtom<string | number>;
1735
+ readonly pointsAtZ?: MaybeReadAtom<string | number>;
1736
+ readonly specularExponent?: MaybeReadAtom<string | number>;
1737
+ readonly x?: MaybeReadAtom<string | number>;
1738
+ readonly y?: MaybeReadAtom<string | number>;
1739
+ readonly z?: MaybeReadAtom<string | number>;
1739
1740
  }
1740
1741
  interface SVGFETileElementProps extends SVGGlobalProps {
1741
1742
  readonly [S_NODE_TYPE]?: SVGFETileElement;
1742
1743
  readonly children?: JsxChildren;
1743
- readonly "color-interpolation-filters"?: MaybeReadonlyAtom<SVGColorInterpolationFilters>;
1744
- readonly height?: MaybeReadonlyAtom<string | number>;
1745
- readonly in?: MaybeReadonlyAtom<string>;
1746
- readonly result?: MaybeReadonlyAtom<string>;
1747
- readonly width?: MaybeReadonlyAtom<string | number>;
1748
- readonly x?: MaybeReadonlyAtom<string | number>;
1749
- readonly y?: MaybeReadonlyAtom<string | number>;
1744
+ readonly "color-interpolation-filters"?: MaybeReadAtom<SVGColorInterpolationFilters>;
1745
+ readonly height?: MaybeReadAtom<string | number>;
1746
+ readonly in?: MaybeReadAtom<string>;
1747
+ readonly result?: MaybeReadAtom<string>;
1748
+ readonly width?: MaybeReadAtom<string | number>;
1749
+ readonly x?: MaybeReadAtom<string | number>;
1750
+ readonly y?: MaybeReadAtom<string | number>;
1750
1751
  }
1751
1752
  interface SVGFETurbulenceElementProps extends SVGGlobalProps {
1752
1753
  readonly [S_NODE_TYPE]?: SVGFETurbulenceElement;
1753
1754
  readonly children?: JsxChildren;
1754
- readonly baseFrequency?: MaybeReadonlyAtom<string | number>;
1755
- readonly "color-interpolation-filters"?: MaybeReadonlyAtom<SVGColorInterpolationFilters>;
1756
- readonly height?: MaybeReadonlyAtom<string | number>;
1757
- readonly numOctaves?: MaybeReadonlyAtom<string | number>;
1758
- readonly result?: MaybeReadonlyAtom<string>;
1759
- readonly seed?: MaybeReadonlyAtom<string | number>;
1760
- readonly stitchTiles?: MaybeReadonlyAtom<"noStitch" | "stitch">;
1761
- readonly type?: MaybeReadonlyAtom<string>;
1762
- readonly width?: MaybeReadonlyAtom<string | number>;
1763
- readonly x?: MaybeReadonlyAtom<string | number>;
1764
- readonly y?: MaybeReadonlyAtom<string | number>;
1755
+ readonly baseFrequency?: MaybeReadAtom<string | number>;
1756
+ readonly "color-interpolation-filters"?: MaybeReadAtom<SVGColorInterpolationFilters>;
1757
+ readonly height?: MaybeReadAtom<string | number>;
1758
+ readonly numOctaves?: MaybeReadAtom<string | number>;
1759
+ readonly result?: MaybeReadAtom<string>;
1760
+ readonly seed?: MaybeReadAtom<string | number>;
1761
+ readonly stitchTiles?: MaybeReadAtom<"noStitch" | "stitch">;
1762
+ readonly type?: MaybeReadAtom<string>;
1763
+ readonly width?: MaybeReadAtom<string | number>;
1764
+ readonly x?: MaybeReadAtom<string | number>;
1765
+ readonly y?: MaybeReadAtom<string | number>;
1765
1766
  }
1766
1767
  interface SVGFilterElementProps extends SVGGlobalProps {
1767
1768
  readonly [S_NODE_TYPE]?: SVGFilterElement;
1768
1769
  readonly children?: JsxChildren;
1769
- readonly filterUnits?: MaybeReadonlyAtom<SVGUnits>;
1770
- readonly height?: MaybeReadonlyAtom<string | number>;
1771
- readonly primitiveUnits?: MaybeReadonlyAtom<SVGUnits>;
1772
- readonly width?: MaybeReadonlyAtom<string | number>;
1773
- readonly x?: MaybeReadonlyAtom<string | number>;
1774
- readonly y?: MaybeReadonlyAtom<string | number>;
1770
+ readonly filterUnits?: MaybeReadAtom<SVGUnits>;
1771
+ readonly height?: MaybeReadAtom<string | number>;
1772
+ readonly primitiveUnits?: MaybeReadAtom<SVGUnits>;
1773
+ readonly width?: MaybeReadAtom<string | number>;
1774
+ readonly x?: MaybeReadAtom<string | number>;
1775
+ readonly y?: MaybeReadAtom<string | number>;
1775
1776
  }
1776
1777
  interface SVGForeignObjectElementProps extends SVGGlobalProps {
1777
1778
  readonly [S_NODE_TYPE]?: SVGForeignObjectElement;
1778
1779
  readonly children?: JsxChildren;
1779
- readonly opacity?: MaybeReadonlyAtom<string | number>;
1780
- readonly overflow?: MaybeReadonlyAtom<SVGOverflow>;
1781
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
1782
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
1783
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
1784
- readonly "vector-effect"?: MaybeReadonlyAtom<SVGVectorEffect>;
1785
- readonly visibility?: MaybeReadonlyAtom<SVGVisibility>;
1786
- readonly x?: MaybeReadonlyAtom<string | number>;
1787
- readonly y?: MaybeReadonlyAtom<string | number>;
1780
+ readonly opacity?: MaybeReadAtom<string | number>;
1781
+ readonly overflow?: MaybeReadAtom<SVGOverflow>;
1782
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
1783
+ readonly requiredExtensions?: MaybeReadAtom<string>;
1784
+ readonly systemLanguage?: MaybeReadAtom<string>;
1785
+ readonly "vector-effect"?: MaybeReadAtom<SVGVectorEffect>;
1786
+ readonly visibility?: MaybeReadAtom<SVGVisibility>;
1787
+ readonly x?: MaybeReadAtom<string | number>;
1788
+ readonly y?: MaybeReadAtom<string | number>;
1788
1789
  }
1789
1790
  interface SVGGElementProps extends SVGGlobalProps {
1790
1791
  readonly [S_NODE_TYPE]?: SVGGElement;
1791
1792
  readonly children?: JsxChildren;
1792
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
1793
- readonly cursor?: MaybeReadonlyAtom<string>;
1794
- readonly mask?: MaybeReadonlyAtom<string>;
1795
- readonly opacity?: MaybeReadonlyAtom<string | number>;
1796
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
1797
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
1798
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
1793
+ readonly "clip-path"?: MaybeReadAtom<string>;
1794
+ readonly cursor?: MaybeReadAtom<string>;
1795
+ readonly mask?: MaybeReadAtom<string>;
1796
+ readonly opacity?: MaybeReadAtom<string | number>;
1797
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
1798
+ readonly requiredExtensions?: MaybeReadAtom<string>;
1799
+ readonly systemLanguage?: MaybeReadAtom<string>;
1799
1800
  }
1800
1801
  interface SVGImageElementProps extends SVGGlobalProps {
1801
1802
  readonly [S_NODE_TYPE]?: SVGImageElement;
1802
1803
  readonly children?: never;
1803
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
1804
- readonly "clip-rule"?: MaybeReadonlyAtom<SVGClipRule>;
1805
- readonly crossorigin?: MaybeReadonlyAtom<SVGCrossOrigin>;
1806
- readonly cursor?: MaybeReadonlyAtom<string>;
1807
- readonly decoding?: MaybeReadonlyAtom<"auto" | "async" | "sync">;
1808
- readonly height?: MaybeReadonlyAtom<string | number>;
1809
- readonly href?: MaybeReadonlyAtom<string>;
1810
- readonly "image-rendering"?: MaybeReadonlyAtom<"auto" | "optimizeSpeed" | "optimizeQuality">;
1811
- readonly mask?: MaybeReadonlyAtom<string>;
1812
- readonly opacity?: MaybeReadonlyAtom<string | number>;
1813
- readonly overflow?: MaybeReadonlyAtom<SVGOverflow>;
1814
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
1815
- readonly preserveAspectRatio?: MaybeReadonlyAtom<string>;
1816
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
1817
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
1818
- readonly "vector-effect"?: MaybeReadonlyAtom<SVGVectorEffect>;
1819
- readonly visibility?: MaybeReadonlyAtom<SVGVisibility>;
1820
- readonly width?: MaybeReadonlyAtom<string | number>;
1821
- readonly x?: MaybeReadonlyAtom<string | number>;
1822
- readonly y?: MaybeReadonlyAtom<string | number>;
1804
+ readonly "clip-path"?: MaybeReadAtom<string>;
1805
+ readonly "clip-rule"?: MaybeReadAtom<SVGClipRule>;
1806
+ readonly crossorigin?: MaybeReadAtom<SVGCrossOrigin>;
1807
+ readonly cursor?: MaybeReadAtom<string>;
1808
+ readonly decoding?: MaybeReadAtom<"auto" | "async" | "sync">;
1809
+ readonly height?: MaybeReadAtom<string | number>;
1810
+ readonly href?: MaybeReadAtom<string>;
1811
+ readonly "image-rendering"?: MaybeReadAtom<"auto" | "optimizeSpeed" | "optimizeQuality">;
1812
+ readonly mask?: MaybeReadAtom<string>;
1813
+ readonly opacity?: MaybeReadAtom<string | number>;
1814
+ readonly overflow?: MaybeReadAtom<SVGOverflow>;
1815
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
1816
+ readonly preserveAspectRatio?: MaybeReadAtom<string>;
1817
+ readonly requiredExtensions?: MaybeReadAtom<string>;
1818
+ readonly systemLanguage?: MaybeReadAtom<string>;
1819
+ readonly "vector-effect"?: MaybeReadAtom<SVGVectorEffect>;
1820
+ readonly visibility?: MaybeReadAtom<SVGVisibility>;
1821
+ readonly width?: MaybeReadAtom<string | number>;
1822
+ readonly x?: MaybeReadAtom<string | number>;
1823
+ readonly y?: MaybeReadAtom<string | number>;
1823
1824
  }
1824
1825
  interface SVGLineElementProps extends SVGGlobalProps {
1825
1826
  readonly [S_NODE_TYPE]?: SVGLineElement;
1826
1827
  readonly children?: never;
1827
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
1828
- readonly "clip-rule"?: MaybeReadonlyAtom<SVGClipRule>;
1829
- readonly cursor?: MaybeReadonlyAtom<string>;
1830
- readonly "marker-end"?: MaybeReadonlyAtom<string>;
1831
- readonly "marker-mid"?: MaybeReadonlyAtom<string>;
1832
- readonly "marker-start"?: MaybeReadonlyAtom<string>;
1833
- readonly mask?: MaybeReadonlyAtom<string>;
1834
- readonly opacity?: MaybeReadonlyAtom<string | number>;
1835
- readonly orient?: MaybeReadonlyAtom<string | number>;
1836
- readonly "paint-order"?: MaybeReadonlyAtom<string>;
1837
- readonly pathLength?: MaybeReadonlyAtom<string | number>;
1838
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
1839
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
1840
- readonly "shape-rendering"?: MaybeReadonlyAtom<SVGShapeRendering>;
1841
- readonly stroke?: MaybeReadonlyAtom<string>;
1842
- readonly "stroke-dasharray"?: MaybeReadonlyAtom<string>;
1843
- readonly "stroke-dashoffset"?: MaybeReadonlyAtom<string | number>;
1844
- readonly "stroke-linecap"?: MaybeReadonlyAtom<SVGStrokeLineCap>;
1845
- readonly "stroke-opacity"?: MaybeReadonlyAtom<string | number>;
1846
- readonly "stroke-width"?: MaybeReadonlyAtom<string | number>;
1847
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
1848
- readonly "vector-effect"?: MaybeReadonlyAtom<SVGVectorEffect>;
1849
- readonly visibility?: MaybeReadonlyAtom<SVGVisibility>;
1850
- readonly x1?: MaybeReadonlyAtom<string | number>;
1851
- readonly x2?: MaybeReadonlyAtom<string | number>;
1852
- readonly y1?: MaybeReadonlyAtom<string | number>;
1853
- readonly y2?: MaybeReadonlyAtom<string | number>;
1828
+ readonly "clip-path"?: MaybeReadAtom<string>;
1829
+ readonly "clip-rule"?: MaybeReadAtom<SVGClipRule>;
1830
+ readonly cursor?: MaybeReadAtom<string>;
1831
+ readonly "marker-end"?: MaybeReadAtom<string>;
1832
+ readonly "marker-mid"?: MaybeReadAtom<string>;
1833
+ readonly "marker-start"?: MaybeReadAtom<string>;
1834
+ readonly mask?: MaybeReadAtom<string>;
1835
+ readonly opacity?: MaybeReadAtom<string | number>;
1836
+ readonly orient?: MaybeReadAtom<string | number>;
1837
+ readonly "paint-order"?: MaybeReadAtom<string>;
1838
+ readonly pathLength?: MaybeReadAtom<string | number>;
1839
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
1840
+ readonly requiredExtensions?: MaybeReadAtom<string>;
1841
+ readonly "shape-rendering"?: MaybeReadAtom<SVGShapeRendering>;
1842
+ readonly stroke?: MaybeReadAtom<string>;
1843
+ readonly "stroke-dasharray"?: MaybeReadAtom<string>;
1844
+ readonly "stroke-dashoffset"?: MaybeReadAtom<string | number>;
1845
+ readonly "stroke-linecap"?: MaybeReadAtom<SVGStrokeLineCap>;
1846
+ readonly "stroke-opacity"?: MaybeReadAtom<string | number>;
1847
+ readonly "stroke-width"?: MaybeReadAtom<string | number>;
1848
+ readonly systemLanguage?: MaybeReadAtom<string>;
1849
+ readonly "vector-effect"?: MaybeReadAtom<SVGVectorEffect>;
1850
+ readonly visibility?: MaybeReadAtom<SVGVisibility>;
1851
+ readonly x1?: MaybeReadAtom<string | number>;
1852
+ readonly x2?: MaybeReadAtom<string | number>;
1853
+ readonly y1?: MaybeReadAtom<string | number>;
1854
+ readonly y2?: MaybeReadAtom<string | number>;
1854
1855
  }
1855
1856
  interface SVGLinearGradientElementProps extends SVGGlobalProps {
1856
1857
  readonly [S_NODE_TYPE]?: SVGLinearGradientElement;
1857
1858
  readonly children?: JsxChildren;
1858
- readonly gradientTransform?: MaybeReadonlyAtom<string>;
1859
- readonly gradientUnits?: MaybeReadonlyAtom<SVGUnits>;
1860
- readonly href?: MaybeReadonlyAtom<string>;
1861
- readonly spreadMethod?: MaybeReadonlyAtom<SVGSpreadMethod>;
1862
- readonly x1?: MaybeReadonlyAtom<string | number>;
1863
- readonly x2?: MaybeReadonlyAtom<string | number>;
1864
- readonly y1?: MaybeReadonlyAtom<string | number>;
1865
- readonly y2?: MaybeReadonlyAtom<string | number>;
1859
+ readonly gradientTransform?: MaybeReadAtom<string>;
1860
+ readonly gradientUnits?: MaybeReadAtom<SVGUnits>;
1861
+ readonly href?: MaybeReadAtom<string>;
1862
+ readonly spreadMethod?: MaybeReadAtom<SVGSpreadMethod>;
1863
+ readonly x1?: MaybeReadAtom<string | number>;
1864
+ readonly x2?: MaybeReadAtom<string | number>;
1865
+ readonly y1?: MaybeReadAtom<string | number>;
1866
+ readonly y2?: MaybeReadAtom<string | number>;
1866
1867
  }
1867
1868
  interface SVGMarkerElementProps extends SVGGlobalProps {
1868
1869
  readonly [S_NODE_TYPE]?: SVGMarkerElement;
1869
1870
  readonly children?: JsxChildren;
1870
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
1871
- readonly cursor?: MaybeReadonlyAtom<string>;
1872
- readonly markerHeight?: MaybeReadonlyAtom<string | number>;
1873
- readonly markerUnits?: MaybeReadonlyAtom<"strokeWidth" | "userSpaceOnUse">;
1874
- readonly markerWidth?: MaybeReadonlyAtom<string | number>;
1875
- readonly mask?: MaybeReadonlyAtom<string>;
1876
- readonly opacity?: MaybeReadonlyAtom<string | number>;
1877
- readonly overflow?: MaybeReadonlyAtom<SVGOverflow>;
1878
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
1879
- readonly preserveAspectRatio?: MaybeReadonlyAtom<string>;
1880
- readonly refX?: MaybeReadonlyAtom<string | number>;
1881
- readonly refY?: MaybeReadonlyAtom<string | number>;
1882
- readonly viewBox?: MaybeReadonlyAtom<string>;
1871
+ readonly "clip-path"?: MaybeReadAtom<string>;
1872
+ readonly cursor?: MaybeReadAtom<string>;
1873
+ readonly markerHeight?: MaybeReadAtom<string | number>;
1874
+ readonly markerUnits?: MaybeReadAtom<"strokeWidth" | "userSpaceOnUse">;
1875
+ readonly markerWidth?: MaybeReadAtom<string | number>;
1876
+ readonly mask?: MaybeReadAtom<string>;
1877
+ readonly opacity?: MaybeReadAtom<string | number>;
1878
+ readonly overflow?: MaybeReadAtom<SVGOverflow>;
1879
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
1880
+ readonly preserveAspectRatio?: MaybeReadAtom<string>;
1881
+ readonly refX?: MaybeReadAtom<string | number>;
1882
+ readonly refY?: MaybeReadAtom<string | number>;
1883
+ readonly viewBox?: MaybeReadAtom<string>;
1883
1884
  }
1884
1885
  interface SVGMaskElementProps extends SVGGlobalProps {
1885
1886
  readonly [S_NODE_TYPE]?: SVGMaskElement;
1886
1887
  readonly children?: JsxChildren;
1887
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
1888
- readonly cursor?: MaybeReadonlyAtom<string>;
1889
- readonly height?: MaybeReadonlyAtom<string | number>;
1890
- readonly mask?: MaybeReadonlyAtom<string>;
1891
- readonly "mask-type"?: MaybeReadonlyAtom<"alpha" | "luminance">;
1892
- readonly maskContentUnits?: MaybeReadonlyAtom<SVGUnits>;
1893
- readonly maskUnits?: MaybeReadonlyAtom<SVGUnits>;
1894
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
1895
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
1896
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
1897
- readonly width?: MaybeReadonlyAtom<string | number>;
1898
- readonly x?: MaybeReadonlyAtom<string | number>;
1899
- readonly y?: MaybeReadonlyAtom<string | number>;
1888
+ readonly "clip-path"?: MaybeReadAtom<string>;
1889
+ readonly cursor?: MaybeReadAtom<string>;
1890
+ readonly height?: MaybeReadAtom<string | number>;
1891
+ readonly mask?: MaybeReadAtom<string>;
1892
+ readonly "mask-type"?: MaybeReadAtom<"alpha" | "luminance">;
1893
+ readonly maskContentUnits?: MaybeReadAtom<SVGUnits>;
1894
+ readonly maskUnits?: MaybeReadAtom<SVGUnits>;
1895
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
1896
+ readonly requiredExtensions?: MaybeReadAtom<string>;
1897
+ readonly systemLanguage?: MaybeReadAtom<string>;
1898
+ readonly width?: MaybeReadAtom<string | number>;
1899
+ readonly x?: MaybeReadAtom<string | number>;
1900
+ readonly y?: MaybeReadAtom<string | number>;
1900
1901
  }
1901
1902
  interface SVGMetadataElementProps extends SVGGlobalProps {
1902
1903
  readonly [S_NODE_TYPE]?: SVGMetadataElement;
@@ -1905,336 +1906,336 @@ interface SVGMetadataElementProps extends SVGGlobalProps {
1905
1906
  interface SVGMPathElementProps extends SVGGlobalProps {
1906
1907
  readonly [S_NODE_TYPE]?: SVGMPathElement;
1907
1908
  readonly children?: JsxChildren;
1908
- readonly href?: MaybeReadonlyAtom<string>;
1909
+ readonly href?: MaybeReadAtom<string>;
1909
1910
  }
1910
1911
  interface SVGPathElementProps extends SVGGlobalProps {
1911
1912
  readonly [S_NODE_TYPE]?: SVGPathElement;
1912
1913
  readonly children?: never;
1913
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
1914
- readonly "clip-rule"?: MaybeReadonlyAtom<SVGClipRule>;
1915
- readonly cursor?: MaybeReadonlyAtom<string>;
1916
- readonly d?: MaybeReadonlyAtom<string>;
1917
- readonly fill?: MaybeReadonlyAtom<string>;
1918
- readonly "fill-opacity"?: MaybeReadonlyAtom<string | number>;
1919
- readonly "fill-rule"?: MaybeReadonlyAtom<SVGFillRule>;
1920
- readonly "marker-end"?: MaybeReadonlyAtom<string>;
1921
- readonly "marker-mid"?: MaybeReadonlyAtom<string>;
1922
- readonly "marker-start"?: MaybeReadonlyAtom<string>;
1923
- readonly mask?: MaybeReadonlyAtom<string>;
1924
- readonly opacity?: MaybeReadonlyAtom<string | number>;
1925
- readonly "paint-order"?: MaybeReadonlyAtom<string>;
1926
- readonly pathLength?: MaybeReadonlyAtom<string | number>;
1927
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
1928
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
1929
- readonly "shape-rendering"?: MaybeReadonlyAtom<SVGShapeRendering>;
1930
- readonly stroke?: MaybeReadonlyAtom<string>;
1931
- readonly "stroke-dasharray"?: MaybeReadonlyAtom<string>;
1932
- readonly "stroke-dashoffset"?: MaybeReadonlyAtom<string | number>;
1933
- readonly "stroke-linecap"?: MaybeReadonlyAtom<SVGStrokeLineCap>;
1934
- readonly "stroke-linejoin"?: MaybeReadonlyAtom<SVGStrokeLineJoin>;
1935
- readonly "stroke-miterlimit"?: MaybeReadonlyAtom<string | number>;
1936
- readonly "stroke-opacity"?: MaybeReadonlyAtom<string | number>;
1937
- readonly "stroke-width"?: MaybeReadonlyAtom<string | number>;
1938
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
1939
- readonly "vector-effect"?: MaybeReadonlyAtom<SVGVectorEffect>;
1940
- readonly visibility?: MaybeReadonlyAtom<SVGVisibility>;
1914
+ readonly "clip-path"?: MaybeReadAtom<string>;
1915
+ readonly "clip-rule"?: MaybeReadAtom<SVGClipRule>;
1916
+ readonly cursor?: MaybeReadAtom<string>;
1917
+ readonly d?: MaybeReadAtom<string>;
1918
+ readonly fill?: MaybeReadAtom<string>;
1919
+ readonly "fill-opacity"?: MaybeReadAtom<string | number>;
1920
+ readonly "fill-rule"?: MaybeReadAtom<SVGFillRule>;
1921
+ readonly "marker-end"?: MaybeReadAtom<string>;
1922
+ readonly "marker-mid"?: MaybeReadAtom<string>;
1923
+ readonly "marker-start"?: MaybeReadAtom<string>;
1924
+ readonly mask?: MaybeReadAtom<string>;
1925
+ readonly opacity?: MaybeReadAtom<string | number>;
1926
+ readonly "paint-order"?: MaybeReadAtom<string>;
1927
+ readonly pathLength?: MaybeReadAtom<string | number>;
1928
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
1929
+ readonly requiredExtensions?: MaybeReadAtom<string>;
1930
+ readonly "shape-rendering"?: MaybeReadAtom<SVGShapeRendering>;
1931
+ readonly stroke?: MaybeReadAtom<string>;
1932
+ readonly "stroke-dasharray"?: MaybeReadAtom<string>;
1933
+ readonly "stroke-dashoffset"?: MaybeReadAtom<string | number>;
1934
+ readonly "stroke-linecap"?: MaybeReadAtom<SVGStrokeLineCap>;
1935
+ readonly "stroke-linejoin"?: MaybeReadAtom<SVGStrokeLineJoin>;
1936
+ readonly "stroke-miterlimit"?: MaybeReadAtom<string | number>;
1937
+ readonly "stroke-opacity"?: MaybeReadAtom<string | number>;
1938
+ readonly "stroke-width"?: MaybeReadAtom<string | number>;
1939
+ readonly systemLanguage?: MaybeReadAtom<string>;
1940
+ readonly "vector-effect"?: MaybeReadAtom<SVGVectorEffect>;
1941
+ readonly visibility?: MaybeReadAtom<SVGVisibility>;
1941
1942
  }
1942
1943
  interface SVGPatternElementProps extends SVGGlobalProps {
1943
1944
  readonly [S_NODE_TYPE]?: SVGPatternElement;
1944
1945
  readonly children?: JsxChildren;
1945
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
1946
- readonly cursor?: MaybeReadonlyAtom<string>;
1947
- readonly height?: MaybeReadonlyAtom<string | number>;
1948
- readonly href?: MaybeReadonlyAtom<string>;
1949
- readonly mask?: MaybeReadonlyAtom<string>;
1950
- readonly overflow?: MaybeReadonlyAtom<SVGOverflow>;
1951
- readonly patternContentUnits?: MaybeReadonlyAtom<SVGUnits>;
1952
- readonly patternTransform?: MaybeReadonlyAtom<string>;
1953
- readonly patternUnits?: MaybeReadonlyAtom<SVGUnits>;
1954
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
1955
- readonly preserveAspectRatio?: MaybeReadonlyAtom<string>;
1956
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
1957
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
1958
- readonly viewBox?: MaybeReadonlyAtom<string>;
1959
- readonly width?: MaybeReadonlyAtom<string | number>;
1960
- readonly x?: MaybeReadonlyAtom<string | number>;
1961
- readonly y?: MaybeReadonlyAtom<string | number>;
1946
+ readonly "clip-path"?: MaybeReadAtom<string>;
1947
+ readonly cursor?: MaybeReadAtom<string>;
1948
+ readonly height?: MaybeReadAtom<string | number>;
1949
+ readonly href?: MaybeReadAtom<string>;
1950
+ readonly mask?: MaybeReadAtom<string>;
1951
+ readonly overflow?: MaybeReadAtom<SVGOverflow>;
1952
+ readonly patternContentUnits?: MaybeReadAtom<SVGUnits>;
1953
+ readonly patternTransform?: MaybeReadAtom<string>;
1954
+ readonly patternUnits?: MaybeReadAtom<SVGUnits>;
1955
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
1956
+ readonly preserveAspectRatio?: MaybeReadAtom<string>;
1957
+ readonly requiredExtensions?: MaybeReadAtom<string>;
1958
+ readonly systemLanguage?: MaybeReadAtom<string>;
1959
+ readonly viewBox?: MaybeReadAtom<string>;
1960
+ readonly width?: MaybeReadAtom<string | number>;
1961
+ readonly x?: MaybeReadAtom<string | number>;
1962
+ readonly y?: MaybeReadAtom<string | number>;
1962
1963
  }
1963
1964
  interface SVGPolygonElementProps extends SVGGlobalProps {
1964
1965
  readonly [S_NODE_TYPE]?: SVGPolygonElement;
1965
1966
  readonly children?: never;
1966
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
1967
- readonly "clip-rule"?: MaybeReadonlyAtom<SVGClipRule>;
1968
- readonly cursor?: MaybeReadonlyAtom<string>;
1969
- readonly fill?: MaybeReadonlyAtom<string>;
1970
- readonly "fill-opacity"?: MaybeReadonlyAtom<string | number>;
1971
- readonly "fill-rule"?: MaybeReadonlyAtom<SVGFillRule>;
1972
- readonly "marker-end"?: MaybeReadonlyAtom<string>;
1973
- readonly "marker-mid"?: MaybeReadonlyAtom<string>;
1974
- readonly "marker-start"?: MaybeReadonlyAtom<string>;
1975
- readonly mask?: MaybeReadonlyAtom<string>;
1976
- readonly opacity?: MaybeReadonlyAtom<string | number>;
1977
- readonly "paint-order"?: MaybeReadonlyAtom<string>;
1978
- readonly pathLength?: MaybeReadonlyAtom<string | number>;
1979
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
1980
- readonly points?: MaybeReadonlyAtom<string>;
1981
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
1982
- readonly "shape-rendering"?: MaybeReadonlyAtom<SVGShapeRendering>;
1983
- readonly stroke?: MaybeReadonlyAtom<string>;
1984
- readonly "stroke-dasharray"?: MaybeReadonlyAtom<string>;
1985
- readonly "stroke-dashoffset"?: MaybeReadonlyAtom<string | number>;
1986
- readonly "stroke-linejoin"?: MaybeReadonlyAtom<SVGStrokeLineJoin>;
1987
- readonly "stroke-miterlimit"?: MaybeReadonlyAtom<string | number>;
1988
- readonly "stroke-opacity"?: MaybeReadonlyAtom<string | number>;
1989
- readonly "stroke-width"?: MaybeReadonlyAtom<string | number>;
1990
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
1991
- readonly "vector-effect"?: MaybeReadonlyAtom<SVGVectorEffect>;
1992
- readonly visibility?: MaybeReadonlyAtom<SVGVisibility>;
1967
+ readonly "clip-path"?: MaybeReadAtom<string>;
1968
+ readonly "clip-rule"?: MaybeReadAtom<SVGClipRule>;
1969
+ readonly cursor?: MaybeReadAtom<string>;
1970
+ readonly fill?: MaybeReadAtom<string>;
1971
+ readonly "fill-opacity"?: MaybeReadAtom<string | number>;
1972
+ readonly "fill-rule"?: MaybeReadAtom<SVGFillRule>;
1973
+ readonly "marker-end"?: MaybeReadAtom<string>;
1974
+ readonly "marker-mid"?: MaybeReadAtom<string>;
1975
+ readonly "marker-start"?: MaybeReadAtom<string>;
1976
+ readonly mask?: MaybeReadAtom<string>;
1977
+ readonly opacity?: MaybeReadAtom<string | number>;
1978
+ readonly "paint-order"?: MaybeReadAtom<string>;
1979
+ readonly pathLength?: MaybeReadAtom<string | number>;
1980
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
1981
+ readonly points?: MaybeReadAtom<string>;
1982
+ readonly requiredExtensions?: MaybeReadAtom<string>;
1983
+ readonly "shape-rendering"?: MaybeReadAtom<SVGShapeRendering>;
1984
+ readonly stroke?: MaybeReadAtom<string>;
1985
+ readonly "stroke-dasharray"?: MaybeReadAtom<string>;
1986
+ readonly "stroke-dashoffset"?: MaybeReadAtom<string | number>;
1987
+ readonly "stroke-linejoin"?: MaybeReadAtom<SVGStrokeLineJoin>;
1988
+ readonly "stroke-miterlimit"?: MaybeReadAtom<string | number>;
1989
+ readonly "stroke-opacity"?: MaybeReadAtom<string | number>;
1990
+ readonly "stroke-width"?: MaybeReadAtom<string | number>;
1991
+ readonly systemLanguage?: MaybeReadAtom<string>;
1992
+ readonly "vector-effect"?: MaybeReadAtom<SVGVectorEffect>;
1993
+ readonly visibility?: MaybeReadAtom<SVGVisibility>;
1993
1994
  }
1994
1995
  interface SVGPolylineElementProps extends SVGGlobalProps {
1995
1996
  readonly [S_NODE_TYPE]?: SVGPolylineElement;
1996
1997
  readonly children?: never;
1997
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
1998
- readonly "clip-rule"?: MaybeReadonlyAtom<SVGClipRule>;
1999
- readonly cursor?: MaybeReadonlyAtom<string>;
2000
- readonly fill?: MaybeReadonlyAtom<string>;
2001
- readonly "fill-opacity"?: MaybeReadonlyAtom<string | number>;
2002
- readonly "fill-rule"?: MaybeReadonlyAtom<SVGFillRule>;
2003
- readonly "marker-end"?: MaybeReadonlyAtom<string>;
2004
- readonly "marker-mid"?: MaybeReadonlyAtom<string>;
2005
- readonly "marker-start"?: MaybeReadonlyAtom<string>;
2006
- readonly mask?: MaybeReadonlyAtom<string>;
2007
- readonly opacity?: MaybeReadonlyAtom<string | number>;
2008
- readonly "paint-order"?: MaybeReadonlyAtom<string>;
2009
- readonly pathLength?: MaybeReadonlyAtom<string | number>;
2010
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
2011
- readonly points?: MaybeReadonlyAtom<string>;
2012
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
2013
- readonly "shape-rendering"?: MaybeReadonlyAtom<SVGShapeRendering>;
2014
- readonly stroke?: MaybeReadonlyAtom<string>;
2015
- readonly "stroke-dasharray"?: MaybeReadonlyAtom<string>;
2016
- readonly "stroke-dashoffset"?: MaybeReadonlyAtom<string | number>;
2017
- readonly "stroke-linecap"?: MaybeReadonlyAtom<SVGStrokeLineCap>;
2018
- readonly "stroke-linejoin"?: MaybeReadonlyAtom<SVGStrokeLineJoin>;
2019
- readonly "stroke-miterlimit"?: MaybeReadonlyAtom<string | number>;
2020
- readonly "stroke-opacity"?: MaybeReadonlyAtom<string | number>;
2021
- readonly "stroke-width"?: MaybeReadonlyAtom<string | number>;
2022
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
2023
- readonly "vector-effect"?: MaybeReadonlyAtom<SVGVectorEffect>;
2024
- readonly visibility?: MaybeReadonlyAtom<SVGVisibility>;
1998
+ readonly "clip-path"?: MaybeReadAtom<string>;
1999
+ readonly "clip-rule"?: MaybeReadAtom<SVGClipRule>;
2000
+ readonly cursor?: MaybeReadAtom<string>;
2001
+ readonly fill?: MaybeReadAtom<string>;
2002
+ readonly "fill-opacity"?: MaybeReadAtom<string | number>;
2003
+ readonly "fill-rule"?: MaybeReadAtom<SVGFillRule>;
2004
+ readonly "marker-end"?: MaybeReadAtom<string>;
2005
+ readonly "marker-mid"?: MaybeReadAtom<string>;
2006
+ readonly "marker-start"?: MaybeReadAtom<string>;
2007
+ readonly mask?: MaybeReadAtom<string>;
2008
+ readonly opacity?: MaybeReadAtom<string | number>;
2009
+ readonly "paint-order"?: MaybeReadAtom<string>;
2010
+ readonly pathLength?: MaybeReadAtom<string | number>;
2011
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
2012
+ readonly points?: MaybeReadAtom<string>;
2013
+ readonly requiredExtensions?: MaybeReadAtom<string>;
2014
+ readonly "shape-rendering"?: MaybeReadAtom<SVGShapeRendering>;
2015
+ readonly stroke?: MaybeReadAtom<string>;
2016
+ readonly "stroke-dasharray"?: MaybeReadAtom<string>;
2017
+ readonly "stroke-dashoffset"?: MaybeReadAtom<string | number>;
2018
+ readonly "stroke-linecap"?: MaybeReadAtom<SVGStrokeLineCap>;
2019
+ readonly "stroke-linejoin"?: MaybeReadAtom<SVGStrokeLineJoin>;
2020
+ readonly "stroke-miterlimit"?: MaybeReadAtom<string | number>;
2021
+ readonly "stroke-opacity"?: MaybeReadAtom<string | number>;
2022
+ readonly "stroke-width"?: MaybeReadAtom<string | number>;
2023
+ readonly systemLanguage?: MaybeReadAtom<string>;
2024
+ readonly "vector-effect"?: MaybeReadAtom<SVGVectorEffect>;
2025
+ readonly visibility?: MaybeReadAtom<SVGVisibility>;
2025
2026
  }
2026
2027
  interface SVGRadialGradientElementProps extends SVGGlobalProps {
2027
2028
  readonly [S_NODE_TYPE]?: SVGRadialGradientElement;
2028
2029
  readonly children?: JsxChildren;
2029
- readonly cx?: MaybeReadonlyAtom<string | number>;
2030
- readonly cy?: MaybeReadonlyAtom<string | number>;
2031
- readonly fr?: MaybeReadonlyAtom<string | number>;
2032
- readonly fx?: MaybeReadonlyAtom<string | number>;
2033
- readonly fy?: MaybeReadonlyAtom<string | number>;
2034
- readonly gradientTransform?: MaybeReadonlyAtom<string>;
2035
- readonly gradientUnits?: MaybeReadonlyAtom<SVGUnits>;
2036
- readonly href?: MaybeReadonlyAtom<string>;
2037
- readonly r?: MaybeReadonlyAtom<string | number>;
2038
- readonly spreadMethod?: MaybeReadonlyAtom<SVGSpreadMethod>;
2030
+ readonly cx?: MaybeReadAtom<string | number>;
2031
+ readonly cy?: MaybeReadAtom<string | number>;
2032
+ readonly fr?: MaybeReadAtom<string | number>;
2033
+ readonly fx?: MaybeReadAtom<string | number>;
2034
+ readonly fy?: MaybeReadAtom<string | number>;
2035
+ readonly gradientTransform?: MaybeReadAtom<string>;
2036
+ readonly gradientUnits?: MaybeReadAtom<SVGUnits>;
2037
+ readonly href?: MaybeReadAtom<string>;
2038
+ readonly r?: MaybeReadAtom<string | number>;
2039
+ readonly spreadMethod?: MaybeReadAtom<SVGSpreadMethod>;
2039
2040
  }
2040
2041
  interface SVGRectElementProps extends SVGGlobalProps {
2041
2042
  readonly [S_NODE_TYPE]?: SVGRectElement;
2042
2043
  readonly children?: never;
2043
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
2044
- readonly "clip-rule"?: MaybeReadonlyAtom<SVGClipRule>;
2045
- readonly cursor?: MaybeReadonlyAtom<string>;
2046
- readonly fill?: MaybeReadonlyAtom<string>;
2047
- readonly "fill-opacity"?: MaybeReadonlyAtom<string | number>;
2048
- readonly height?: MaybeReadonlyAtom<string | number>;
2049
- readonly "marker-end"?: MaybeReadonlyAtom<string>;
2050
- readonly "marker-mid"?: MaybeReadonlyAtom<string>;
2051
- readonly "marker-start"?: MaybeReadonlyAtom<string>;
2052
- readonly mask?: MaybeReadonlyAtom<string>;
2053
- readonly opacity?: MaybeReadonlyAtom<string | number>;
2054
- readonly "paint-order"?: MaybeReadonlyAtom<string>;
2055
- readonly pathLength?: MaybeReadonlyAtom<string | number>;
2056
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
2057
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
2058
- readonly rx?: MaybeReadonlyAtom<string | number>;
2059
- readonly ry?: MaybeReadonlyAtom<string | number>;
2060
- readonly "shape-rendering"?: MaybeReadonlyAtom<SVGShapeRendering>;
2061
- readonly stroke?: MaybeReadonlyAtom<string>;
2062
- readonly "stroke-dasharray"?: MaybeReadonlyAtom<string>;
2063
- readonly "stroke-dashoffset"?: MaybeReadonlyAtom<string | number>;
2064
- readonly "stroke-linejoin"?: MaybeReadonlyAtom<SVGStrokeLineJoin>;
2065
- readonly "stroke-miterlimit"?: MaybeReadonlyAtom<string | number>;
2066
- readonly "stroke-opacity"?: MaybeReadonlyAtom<string | number>;
2067
- readonly "stroke-width"?: MaybeReadonlyAtom<string | number>;
2068
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
2069
- readonly "vector-effect"?: MaybeReadonlyAtom<SVGVectorEffect>;
2070
- readonly visibility?: MaybeReadonlyAtom<SVGVisibility>;
2071
- readonly width?: MaybeReadonlyAtom<string | number>;
2072
- readonly x?: MaybeReadonlyAtom<string | number>;
2073
- readonly y?: MaybeReadonlyAtom<string | number>;
2044
+ readonly "clip-path"?: MaybeReadAtom<string>;
2045
+ readonly "clip-rule"?: MaybeReadAtom<SVGClipRule>;
2046
+ readonly cursor?: MaybeReadAtom<string>;
2047
+ readonly fill?: MaybeReadAtom<string>;
2048
+ readonly "fill-opacity"?: MaybeReadAtom<string | number>;
2049
+ readonly height?: MaybeReadAtom<string | number>;
2050
+ readonly "marker-end"?: MaybeReadAtom<string>;
2051
+ readonly "marker-mid"?: MaybeReadAtom<string>;
2052
+ readonly "marker-start"?: MaybeReadAtom<string>;
2053
+ readonly mask?: MaybeReadAtom<string>;
2054
+ readonly opacity?: MaybeReadAtom<string | number>;
2055
+ readonly "paint-order"?: MaybeReadAtom<string>;
2056
+ readonly pathLength?: MaybeReadAtom<string | number>;
2057
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
2058
+ readonly requiredExtensions?: MaybeReadAtom<string>;
2059
+ readonly rx?: MaybeReadAtom<string | number>;
2060
+ readonly ry?: MaybeReadAtom<string | number>;
2061
+ readonly "shape-rendering"?: MaybeReadAtom<SVGShapeRendering>;
2062
+ readonly stroke?: MaybeReadAtom<string>;
2063
+ readonly "stroke-dasharray"?: MaybeReadAtom<string>;
2064
+ readonly "stroke-dashoffset"?: MaybeReadAtom<string | number>;
2065
+ readonly "stroke-linejoin"?: MaybeReadAtom<SVGStrokeLineJoin>;
2066
+ readonly "stroke-miterlimit"?: MaybeReadAtom<string | number>;
2067
+ readonly "stroke-opacity"?: MaybeReadAtom<string | number>;
2068
+ readonly "stroke-width"?: MaybeReadAtom<string | number>;
2069
+ readonly systemLanguage?: MaybeReadAtom<string>;
2070
+ readonly "vector-effect"?: MaybeReadAtom<SVGVectorEffect>;
2071
+ readonly visibility?: MaybeReadAtom<SVGVisibility>;
2072
+ readonly width?: MaybeReadAtom<string | number>;
2073
+ readonly x?: MaybeReadAtom<string | number>;
2074
+ readonly y?: MaybeReadAtom<string | number>;
2074
2075
  }
2075
2076
  interface SVGSetElementProps extends SVGGlobalProps {
2076
2077
  readonly [S_NODE_TYPE]?: SVGSetElement;
2077
2078
  readonly children?: JsxChildren;
2078
- readonly attributeName?: MaybeReadonlyAtom<string>;
2079
- readonly begin?: MaybeReadonlyAtom<string>;
2080
- readonly dur?: MaybeReadonlyAtom<string | number>;
2081
- readonly end?: MaybeReadonlyAtom<string>;
2082
- readonly fill?: MaybeReadonlyAtom<SVGFillMode>;
2083
- readonly href?: MaybeReadonlyAtom<string>;
2084
- readonly keyPoints?: MaybeReadonlyAtom<string>;
2085
- readonly max?: MaybeReadonlyAtom<string>;
2086
- readonly min?: MaybeReadonlyAtom<string>;
2087
- readonly repeatCount?: MaybeReadonlyAtom<number | "indefinite">;
2088
- readonly repeatDur?: MaybeReadonlyAtom<string | number>;
2089
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
2090
- readonly restart?: MaybeReadonlyAtom<SVGRestart>;
2091
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
2092
- readonly to?: MaybeReadonlyAtom<string | number>;
2079
+ readonly attributeName?: MaybeReadAtom<string>;
2080
+ readonly begin?: MaybeReadAtom<string>;
2081
+ readonly dur?: MaybeReadAtom<string | number>;
2082
+ readonly end?: MaybeReadAtom<string>;
2083
+ readonly fill?: MaybeReadAtom<SVGFillMode>;
2084
+ readonly href?: MaybeReadAtom<string>;
2085
+ readonly keyPoints?: MaybeReadAtom<string>;
2086
+ readonly max?: MaybeReadAtom<string>;
2087
+ readonly min?: MaybeReadAtom<string>;
2088
+ readonly repeatCount?: MaybeReadAtom<number | "indefinite">;
2089
+ readonly repeatDur?: MaybeReadAtom<string | number>;
2090
+ readonly requiredExtensions?: MaybeReadAtom<string>;
2091
+ readonly restart?: MaybeReadAtom<SVGRestart>;
2092
+ readonly systemLanguage?: MaybeReadAtom<string>;
2093
+ readonly to?: MaybeReadAtom<string | number>;
2093
2094
  }
2094
2095
  interface SVGStopElementProps extends SVGGlobalProps {
2095
2096
  readonly [S_NODE_TYPE]?: SVGStopElement;
2096
2097
  readonly children?: never;
2097
- readonly "stop-color"?: MaybeReadonlyAtom<string>;
2098
- readonly "stop-opacity"?: MaybeReadonlyAtom<string | number>;
2098
+ readonly "stop-color"?: MaybeReadAtom<string>;
2099
+ readonly "stop-opacity"?: MaybeReadAtom<string | number>;
2099
2100
  }
2100
2101
  interface SVGSVGElementProps extends SVGGlobalProps {
2101
2102
  readonly [S_NODE_TYPE]?: SVGSVGElement;
2102
2103
  readonly children?: JsxChildren;
2103
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
2104
- readonly cursor?: MaybeReadonlyAtom<string>;
2105
- readonly fill?: MaybeReadonlyAtom<string>;
2106
- readonly height?: MaybeReadonlyAtom<string | number>;
2107
- readonly mask?: MaybeReadonlyAtom<string>;
2108
- readonly opacity?: MaybeReadonlyAtom<string | number>;
2109
- readonly overflow?: MaybeReadonlyAtom<SVGOverflow>;
2110
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
2111
- readonly preserveAspectRatio?: MaybeReadonlyAtom<string>;
2112
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
2113
- readonly stroke?: MaybeReadonlyAtom<string>;
2114
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
2115
- readonly viewBox?: MaybeReadonlyAtom<string>;
2116
- readonly width?: MaybeReadonlyAtom<string | number>;
2117
- readonly x?: MaybeReadonlyAtom<string | number>;
2118
- readonly y?: MaybeReadonlyAtom<string | number>;
2104
+ readonly "clip-path"?: MaybeReadAtom<string>;
2105
+ readonly cursor?: MaybeReadAtom<string>;
2106
+ readonly fill?: MaybeReadAtom<string>;
2107
+ readonly height?: MaybeReadAtom<string | number>;
2108
+ readonly mask?: MaybeReadAtom<string>;
2109
+ readonly opacity?: MaybeReadAtom<string | number>;
2110
+ readonly overflow?: MaybeReadAtom<SVGOverflow>;
2111
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
2112
+ readonly preserveAspectRatio?: MaybeReadAtom<string>;
2113
+ readonly requiredExtensions?: MaybeReadAtom<string>;
2114
+ readonly stroke?: MaybeReadAtom<string>;
2115
+ readonly systemLanguage?: MaybeReadAtom<string>;
2116
+ readonly viewBox?: MaybeReadAtom<string>;
2117
+ readonly width?: MaybeReadAtom<string | number>;
2118
+ readonly x?: MaybeReadAtom<string | number>;
2119
+ readonly y?: MaybeReadAtom<string | number>;
2119
2120
  }
2120
2121
  interface SVGSwitchElementProps extends SVGGlobalProps {
2121
2122
  readonly [S_NODE_TYPE]?: SVGSwitchElement;
2122
2123
  readonly children?: JsxChildren;
2123
- readonly cursor?: MaybeReadonlyAtom<string>;
2124
- readonly opacity?: MaybeReadonlyAtom<string | number>;
2125
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
2126
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
2127
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
2124
+ readonly cursor?: MaybeReadAtom<string>;
2125
+ readonly opacity?: MaybeReadAtom<string | number>;
2126
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
2127
+ readonly requiredExtensions?: MaybeReadAtom<string>;
2128
+ readonly systemLanguage?: MaybeReadAtom<string>;
2128
2129
  }
2129
2130
  interface SVGSymbolElementProps extends SVGGlobalProps {
2130
2131
  readonly [S_NODE_TYPE]?: SVGSymbolElement;
2131
2132
  readonly children?: JsxChildren;
2132
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
2133
- readonly cursor?: MaybeReadonlyAtom<string>;
2134
- readonly mask?: MaybeReadonlyAtom<string>;
2135
- readonly opacity?: MaybeReadonlyAtom<string | number>;
2136
- readonly overflow?: MaybeReadonlyAtom<SVGOverflow>;
2137
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
2138
- readonly preserveAspectRatio?: MaybeReadonlyAtom<string>;
2139
- readonly viewBox?: MaybeReadonlyAtom<string>;
2133
+ readonly "clip-path"?: MaybeReadAtom<string>;
2134
+ readonly cursor?: MaybeReadAtom<string>;
2135
+ readonly mask?: MaybeReadAtom<string>;
2136
+ readonly opacity?: MaybeReadAtom<string | number>;
2137
+ readonly overflow?: MaybeReadAtom<SVGOverflow>;
2138
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
2139
+ readonly preserveAspectRatio?: MaybeReadAtom<string>;
2140
+ readonly viewBox?: MaybeReadAtom<string>;
2140
2141
  }
2141
2142
  interface SVGTextElementProps extends SVGGlobalProps {
2142
2143
  readonly [S_NODE_TYPE]?: SVGTextElement;
2143
2144
  readonly children?: JsxChildren;
2144
- readonly "alignment-baseline"?: MaybeReadonlyAtom<SVGAlignmentBaseline>;
2145
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
2146
- readonly "clip-rule"?: MaybeReadonlyAtom<SVGClipRule>;
2147
- readonly cursor?: MaybeReadonlyAtom<string>;
2148
- readonly direction?: MaybeReadonlyAtom<SVGTextDirection>;
2149
- readonly "dominant-baseline"?: MaybeReadonlyAtom<SVGDominantBaseline>;
2150
- readonly dx?: MaybeReadonlyAtom<string | number>;
2151
- readonly dy?: MaybeReadonlyAtom<string | number>;
2152
- readonly fill?: MaybeReadonlyAtom<string>;
2153
- readonly "fill-opacity"?: MaybeReadonlyAtom<string | number>;
2154
- readonly "fill-rule"?: MaybeReadonlyAtom<SVGFillRule>;
2155
- readonly "font-family"?: MaybeReadonlyAtom<string>;
2156
- readonly "font-size"?: MaybeReadonlyAtom<string | number>;
2157
- readonly "font-size-adjust"?: MaybeReadonlyAtom<string>;
2158
- readonly "font-style"?: MaybeReadonlyAtom<SVGFontStyle>;
2159
- readonly "font-variant"?: MaybeReadonlyAtom<string>;
2160
- readonly "font-weight"?: MaybeReadonlyAtom<string | number>;
2161
- readonly lengthAdjust?: MaybeReadonlyAtom<SVGLengthAdjust>;
2162
- readonly "letter-spacing"?: MaybeReadonlyAtom<string>;
2163
- readonly mask?: MaybeReadonlyAtom<string>;
2164
- readonly opacity?: MaybeReadonlyAtom<string | number>;
2165
- readonly overflow?: MaybeReadonlyAtom<SVGOverflow>;
2166
- readonly "paint-order"?: MaybeReadonlyAtom<string>;
2167
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
2168
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
2169
- readonly stroke?: MaybeReadonlyAtom<string>;
2170
- readonly "stroke-dasharray"?: MaybeReadonlyAtom<string>;
2171
- readonly "stroke-dashoffset"?: MaybeReadonlyAtom<string | number>;
2172
- readonly "stroke-linecap"?: MaybeReadonlyAtom<SVGStrokeLineCap>;
2173
- readonly "stroke-linejoin"?: MaybeReadonlyAtom<SVGStrokeLineJoin>;
2174
- readonly "stroke-miterlimit"?: MaybeReadonlyAtom<string | number>;
2175
- readonly "stroke-opacity"?: MaybeReadonlyAtom<string | number>;
2176
- readonly "stroke-width"?: MaybeReadonlyAtom<string | number>;
2177
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
2178
- readonly "text-anchor"?: MaybeReadonlyAtom<SVGTextAnchor>;
2179
- readonly "text-decoration"?: MaybeReadonlyAtom<string>;
2180
- readonly "text-overflow"?: MaybeReadonlyAtom<"clip" | "ellipses">;
2181
- readonly "text-rendering"?: MaybeReadonlyAtom<"auto" | "optimizeSpeed" | "geometricPrecision" | "optimizeLegibility">;
2182
- readonly textLength?: MaybeReadonlyAtom<string | number>;
2183
- readonly "unicode-bidi"?: MaybeReadonlyAtom<SVGUnicodeBidi>;
2184
- readonly "vector-effect"?: MaybeReadonlyAtom<SVGVectorEffect>;
2185
- readonly visibility?: MaybeReadonlyAtom<SVGVisibility>;
2186
- readonly "white-space"?: MaybeReadonlyAtom<SVGWhiteSpace>;
2187
- readonly "word-spacing"?: MaybeReadonlyAtom<string | number>;
2188
- readonly "writing-mode"?: MaybeReadonlyAtom<SVGWritingMode>;
2189
- readonly x?: MaybeReadonlyAtom<string | number>;
2190
- readonly y?: MaybeReadonlyAtom<string | number>;
2145
+ readonly "alignment-baseline"?: MaybeReadAtom<SVGAlignmentBaseline>;
2146
+ readonly "clip-path"?: MaybeReadAtom<string>;
2147
+ readonly "clip-rule"?: MaybeReadAtom<SVGClipRule>;
2148
+ readonly cursor?: MaybeReadAtom<string>;
2149
+ readonly direction?: MaybeReadAtom<SVGTextDirection>;
2150
+ readonly "dominant-baseline"?: MaybeReadAtom<SVGDominantBaseline>;
2151
+ readonly dx?: MaybeReadAtom<string | number>;
2152
+ readonly dy?: MaybeReadAtom<string | number>;
2153
+ readonly fill?: MaybeReadAtom<string>;
2154
+ readonly "fill-opacity"?: MaybeReadAtom<string | number>;
2155
+ readonly "fill-rule"?: MaybeReadAtom<SVGFillRule>;
2156
+ readonly "font-family"?: MaybeReadAtom<string>;
2157
+ readonly "font-size"?: MaybeReadAtom<string | number>;
2158
+ readonly "font-size-adjust"?: MaybeReadAtom<string>;
2159
+ readonly "font-style"?: MaybeReadAtom<SVGFontStyle>;
2160
+ readonly "font-variant"?: MaybeReadAtom<string>;
2161
+ readonly "font-weight"?: MaybeReadAtom<string | number>;
2162
+ readonly lengthAdjust?: MaybeReadAtom<SVGLengthAdjust>;
2163
+ readonly "letter-spacing"?: MaybeReadAtom<string>;
2164
+ readonly mask?: MaybeReadAtom<string>;
2165
+ readonly opacity?: MaybeReadAtom<string | number>;
2166
+ readonly overflow?: MaybeReadAtom<SVGOverflow>;
2167
+ readonly "paint-order"?: MaybeReadAtom<string>;
2168
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
2169
+ readonly requiredExtensions?: MaybeReadAtom<string>;
2170
+ readonly stroke?: MaybeReadAtom<string>;
2171
+ readonly "stroke-dasharray"?: MaybeReadAtom<string>;
2172
+ readonly "stroke-dashoffset"?: MaybeReadAtom<string | number>;
2173
+ readonly "stroke-linecap"?: MaybeReadAtom<SVGStrokeLineCap>;
2174
+ readonly "stroke-linejoin"?: MaybeReadAtom<SVGStrokeLineJoin>;
2175
+ readonly "stroke-miterlimit"?: MaybeReadAtom<string | number>;
2176
+ readonly "stroke-opacity"?: MaybeReadAtom<string | number>;
2177
+ readonly "stroke-width"?: MaybeReadAtom<string | number>;
2178
+ readonly systemLanguage?: MaybeReadAtom<string>;
2179
+ readonly "text-anchor"?: MaybeReadAtom<SVGTextAnchor>;
2180
+ readonly "text-decoration"?: MaybeReadAtom<string>;
2181
+ readonly "text-overflow"?: MaybeReadAtom<"clip" | "ellipses">;
2182
+ readonly "text-rendering"?: MaybeReadAtom<"auto" | "optimizeSpeed" | "geometricPrecision" | "optimizeLegibility">;
2183
+ readonly textLength?: MaybeReadAtom<string | number>;
2184
+ readonly "unicode-bidi"?: MaybeReadAtom<SVGUnicodeBidi>;
2185
+ readonly "vector-effect"?: MaybeReadAtom<SVGVectorEffect>;
2186
+ readonly visibility?: MaybeReadAtom<SVGVisibility>;
2187
+ readonly "white-space"?: MaybeReadAtom<SVGWhiteSpace>;
2188
+ readonly "word-spacing"?: MaybeReadAtom<string | number>;
2189
+ readonly "writing-mode"?: MaybeReadAtom<SVGWritingMode>;
2190
+ readonly x?: MaybeReadAtom<string | number>;
2191
+ readonly y?: MaybeReadAtom<string | number>;
2191
2192
  }
2192
2193
  interface SVGTextPathElementProps extends SVGGlobalProps {
2193
2194
  readonly [S_NODE_TYPE]?: SVGTextPathElement;
2194
2195
  readonly children?: JsxChildren;
2195
- readonly "alignment-baseline"?: MaybeReadonlyAtom<SVGAlignmentBaseline>;
2196
- readonly "baseline-shift"?: MaybeReadonlyAtom<string>;
2197
- readonly direction?: MaybeReadonlyAtom<SVGTextDirection>;
2198
- readonly "dominant-baseline"?: MaybeReadonlyAtom<SVGDominantBaseline>;
2199
- readonly fill?: MaybeReadonlyAtom<string>;
2200
- readonly "fill-opacity"?: MaybeReadonlyAtom<string | number>;
2201
- readonly "fill-rule"?: MaybeReadonlyAtom<SVGFillRule>;
2202
- readonly "font-family"?: MaybeReadonlyAtom<string>;
2203
- readonly "font-size"?: MaybeReadonlyAtom<string | number>;
2204
- readonly "font-size-adjust"?: MaybeReadonlyAtom<string>;
2205
- readonly "font-style"?: MaybeReadonlyAtom<SVGFontStyle>;
2206
- readonly "font-variant"?: MaybeReadonlyAtom<string>;
2207
- readonly "font-weight"?: MaybeReadonlyAtom<string | number>;
2208
- readonly href?: MaybeReadonlyAtom<string>;
2209
- readonly lengthAdjust?: MaybeReadonlyAtom<SVGLengthAdjust>;
2210
- readonly "letter-spacing"?: MaybeReadonlyAtom<string>;
2211
- readonly method?: MaybeReadonlyAtom<"align" | "stretch">;
2212
- readonly opacity?: MaybeReadonlyAtom<string | number>;
2213
- readonly "paint-order"?: MaybeReadonlyAtom<string>;
2214
- readonly path?: MaybeReadonlyAtom<string>;
2215
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
2216
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
2217
- readonly spacing?: MaybeReadonlyAtom<"auto" | "exact">;
2218
- readonly startOffset?: MaybeReadonlyAtom<string | number>;
2219
- readonly stroke?: MaybeReadonlyAtom<string>;
2220
- readonly "stroke-dasharray"?: MaybeReadonlyAtom<string>;
2221
- readonly "stroke-dashoffset"?: MaybeReadonlyAtom<string | number>;
2222
- readonly "stroke-linecap"?: MaybeReadonlyAtom<SVGStrokeLineCap>;
2223
- readonly "stroke-linejoin"?: MaybeReadonlyAtom<SVGStrokeLineJoin>;
2224
- readonly "stroke-miterlimit"?: MaybeReadonlyAtom<string | number>;
2225
- readonly "stroke-opacity"?: MaybeReadonlyAtom<string | number>;
2226
- readonly "stroke-width"?: MaybeReadonlyAtom<string | number>;
2227
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
2228
- readonly "text-anchor"?: MaybeReadonlyAtom<SVGTextAnchor>;
2229
- readonly "text-decoration"?: MaybeReadonlyAtom<string>;
2230
- readonly "text-overflow"?: MaybeReadonlyAtom<"clip" | "ellipses">;
2231
- readonly textLength?: MaybeReadonlyAtom<string | number>;
2232
- readonly "unicode-bidi"?: MaybeReadonlyAtom<SVGUnicodeBidi>;
2233
- readonly "vector-effect"?: MaybeReadonlyAtom<SVGVectorEffect>;
2234
- readonly visibility?: MaybeReadonlyAtom<SVGVisibility>;
2235
- readonly "white-space"?: MaybeReadonlyAtom<SVGWhiteSpace>;
2236
- readonly "word-spacing"?: MaybeReadonlyAtom<string | number>;
2237
- readonly "writing-mode"?: MaybeReadonlyAtom<SVGWritingMode>;
2196
+ readonly "alignment-baseline"?: MaybeReadAtom<SVGAlignmentBaseline>;
2197
+ readonly "baseline-shift"?: MaybeReadAtom<string>;
2198
+ readonly direction?: MaybeReadAtom<SVGTextDirection>;
2199
+ readonly "dominant-baseline"?: MaybeReadAtom<SVGDominantBaseline>;
2200
+ readonly fill?: MaybeReadAtom<string>;
2201
+ readonly "fill-opacity"?: MaybeReadAtom<string | number>;
2202
+ readonly "fill-rule"?: MaybeReadAtom<SVGFillRule>;
2203
+ readonly "font-family"?: MaybeReadAtom<string>;
2204
+ readonly "font-size"?: MaybeReadAtom<string | number>;
2205
+ readonly "font-size-adjust"?: MaybeReadAtom<string>;
2206
+ readonly "font-style"?: MaybeReadAtom<SVGFontStyle>;
2207
+ readonly "font-variant"?: MaybeReadAtom<string>;
2208
+ readonly "font-weight"?: MaybeReadAtom<string | number>;
2209
+ readonly href?: MaybeReadAtom<string>;
2210
+ readonly lengthAdjust?: MaybeReadAtom<SVGLengthAdjust>;
2211
+ readonly "letter-spacing"?: MaybeReadAtom<string>;
2212
+ readonly method?: MaybeReadAtom<"align" | "stretch">;
2213
+ readonly opacity?: MaybeReadAtom<string | number>;
2214
+ readonly "paint-order"?: MaybeReadAtom<string>;
2215
+ readonly path?: MaybeReadAtom<string>;
2216
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
2217
+ readonly requiredExtensions?: MaybeReadAtom<string>;
2218
+ readonly spacing?: MaybeReadAtom<"auto" | "exact">;
2219
+ readonly startOffset?: MaybeReadAtom<string | number>;
2220
+ readonly stroke?: MaybeReadAtom<string>;
2221
+ readonly "stroke-dasharray"?: MaybeReadAtom<string>;
2222
+ readonly "stroke-dashoffset"?: MaybeReadAtom<string | number>;
2223
+ readonly "stroke-linecap"?: MaybeReadAtom<SVGStrokeLineCap>;
2224
+ readonly "stroke-linejoin"?: MaybeReadAtom<SVGStrokeLineJoin>;
2225
+ readonly "stroke-miterlimit"?: MaybeReadAtom<string | number>;
2226
+ readonly "stroke-opacity"?: MaybeReadAtom<string | number>;
2227
+ readonly "stroke-width"?: MaybeReadAtom<string | number>;
2228
+ readonly systemLanguage?: MaybeReadAtom<string>;
2229
+ readonly "text-anchor"?: MaybeReadAtom<SVGTextAnchor>;
2230
+ readonly "text-decoration"?: MaybeReadAtom<string>;
2231
+ readonly "text-overflow"?: MaybeReadAtom<"clip" | "ellipses">;
2232
+ readonly textLength?: MaybeReadAtom<string | number>;
2233
+ readonly "unicode-bidi"?: MaybeReadAtom<SVGUnicodeBidi>;
2234
+ readonly "vector-effect"?: MaybeReadAtom<SVGVectorEffect>;
2235
+ readonly visibility?: MaybeReadAtom<SVGVisibility>;
2236
+ readonly "white-space"?: MaybeReadAtom<SVGWhiteSpace>;
2237
+ readonly "word-spacing"?: MaybeReadAtom<string | number>;
2238
+ readonly "writing-mode"?: MaybeReadAtom<SVGWritingMode>;
2238
2239
  }
2239
2240
  interface SVGTitleElementProps extends SVGGlobalProps {
2240
2241
  readonly [S_NODE_TYPE]?: SVGTitleElement;
@@ -2243,72 +2244,72 @@ interface SVGTitleElementProps extends SVGGlobalProps {
2243
2244
  interface SVGTSpanElementProps extends SVGGlobalProps {
2244
2245
  readonly [S_NODE_TYPE]?: SVGTSpanElement;
2245
2246
  readonly children?: JsxChildren;
2246
- readonly "alignment-baseline"?: MaybeReadonlyAtom<SVGAlignmentBaseline>;
2247
- readonly "baseline-shift"?: MaybeReadonlyAtom<string>;
2248
- readonly direction?: MaybeReadonlyAtom<SVGTextDirection>;
2249
- readonly "dominant-baseline"?: MaybeReadonlyAtom<SVGDominantBaseline>;
2250
- readonly dx?: MaybeReadonlyAtom<string | number>;
2251
- readonly dy?: MaybeReadonlyAtom<string | number>;
2252
- readonly fill?: MaybeReadonlyAtom<string>;
2253
- readonly "fill-opacity"?: MaybeReadonlyAtom<string | number>;
2254
- readonly "fill-rule"?: MaybeReadonlyAtom<SVGFillRule>;
2255
- readonly "font-family"?: MaybeReadonlyAtom<string>;
2256
- readonly "font-size"?: MaybeReadonlyAtom<string | number>;
2257
- readonly "font-size-adjust"?: MaybeReadonlyAtom<string>;
2258
- readonly "font-style"?: MaybeReadonlyAtom<SVGFontStyle>;
2259
- readonly "font-variant"?: MaybeReadonlyAtom<string>;
2260
- readonly "font-weight"?: MaybeReadonlyAtom<string | number>;
2261
- readonly lengthAdjust?: MaybeReadonlyAtom<SVGLengthAdjust>;
2262
- readonly "letter-spacing"?: MaybeReadonlyAtom<string>;
2263
- readonly opacity?: MaybeReadonlyAtom<string | number>;
2264
- readonly "paint-order"?: MaybeReadonlyAtom<string>;
2265
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
2266
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
2267
- readonly stroke?: MaybeReadonlyAtom<string>;
2268
- readonly "stroke-dasharray"?: MaybeReadonlyAtom<string>;
2269
- readonly "stroke-dashoffset"?: MaybeReadonlyAtom<string | number>;
2270
- readonly "stroke-linecap"?: MaybeReadonlyAtom<SVGStrokeLineCap>;
2271
- readonly "stroke-linejoin"?: MaybeReadonlyAtom<SVGStrokeLineJoin>;
2272
- readonly "stroke-miterlimit"?: MaybeReadonlyAtom<string | number>;
2273
- readonly "stroke-opacity"?: MaybeReadonlyAtom<string | number>;
2274
- readonly "stroke-width"?: MaybeReadonlyAtom<string | number>;
2275
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
2276
- readonly "text-anchor"?: MaybeReadonlyAtom<SVGTextAnchor>;
2277
- readonly "text-decoration"?: MaybeReadonlyAtom<string>;
2278
- readonly "text-overflow"?: MaybeReadonlyAtom<"clip" | "ellipses">;
2279
- readonly textLength?: MaybeReadonlyAtom<string | number>;
2280
- readonly "unicode-bidi"?: MaybeReadonlyAtom<SVGUnicodeBidi>;
2281
- readonly "vector-effect"?: MaybeReadonlyAtom<SVGVectorEffect>;
2282
- readonly visibility?: MaybeReadonlyAtom<SVGVisibility>;
2283
- readonly "white-space"?: MaybeReadonlyAtom<SVGWhiteSpace>;
2284
- readonly "word-spacing"?: MaybeReadonlyAtom<string | number>;
2285
- readonly "writing-mode"?: MaybeReadonlyAtom<SVGWritingMode>;
2286
- readonly x?: MaybeReadonlyAtom<string | number>;
2287
- readonly y?: MaybeReadonlyAtom<string | number>;
2247
+ readonly "alignment-baseline"?: MaybeReadAtom<SVGAlignmentBaseline>;
2248
+ readonly "baseline-shift"?: MaybeReadAtom<string>;
2249
+ readonly direction?: MaybeReadAtom<SVGTextDirection>;
2250
+ readonly "dominant-baseline"?: MaybeReadAtom<SVGDominantBaseline>;
2251
+ readonly dx?: MaybeReadAtom<string | number>;
2252
+ readonly dy?: MaybeReadAtom<string | number>;
2253
+ readonly fill?: MaybeReadAtom<string>;
2254
+ readonly "fill-opacity"?: MaybeReadAtom<string | number>;
2255
+ readonly "fill-rule"?: MaybeReadAtom<SVGFillRule>;
2256
+ readonly "font-family"?: MaybeReadAtom<string>;
2257
+ readonly "font-size"?: MaybeReadAtom<string | number>;
2258
+ readonly "font-size-adjust"?: MaybeReadAtom<string>;
2259
+ readonly "font-style"?: MaybeReadAtom<SVGFontStyle>;
2260
+ readonly "font-variant"?: MaybeReadAtom<string>;
2261
+ readonly "font-weight"?: MaybeReadAtom<string | number>;
2262
+ readonly lengthAdjust?: MaybeReadAtom<SVGLengthAdjust>;
2263
+ readonly "letter-spacing"?: MaybeReadAtom<string>;
2264
+ readonly opacity?: MaybeReadAtom<string | number>;
2265
+ readonly "paint-order"?: MaybeReadAtom<string>;
2266
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
2267
+ readonly requiredExtensions?: MaybeReadAtom<string>;
2268
+ readonly stroke?: MaybeReadAtom<string>;
2269
+ readonly "stroke-dasharray"?: MaybeReadAtom<string>;
2270
+ readonly "stroke-dashoffset"?: MaybeReadAtom<string | number>;
2271
+ readonly "stroke-linecap"?: MaybeReadAtom<SVGStrokeLineCap>;
2272
+ readonly "stroke-linejoin"?: MaybeReadAtom<SVGStrokeLineJoin>;
2273
+ readonly "stroke-miterlimit"?: MaybeReadAtom<string | number>;
2274
+ readonly "stroke-opacity"?: MaybeReadAtom<string | number>;
2275
+ readonly "stroke-width"?: MaybeReadAtom<string | number>;
2276
+ readonly systemLanguage?: MaybeReadAtom<string>;
2277
+ readonly "text-anchor"?: MaybeReadAtom<SVGTextAnchor>;
2278
+ readonly "text-decoration"?: MaybeReadAtom<string>;
2279
+ readonly "text-overflow"?: MaybeReadAtom<"clip" | "ellipses">;
2280
+ readonly textLength?: MaybeReadAtom<string | number>;
2281
+ readonly "unicode-bidi"?: MaybeReadAtom<SVGUnicodeBidi>;
2282
+ readonly "vector-effect"?: MaybeReadAtom<SVGVectorEffect>;
2283
+ readonly visibility?: MaybeReadAtom<SVGVisibility>;
2284
+ readonly "white-space"?: MaybeReadAtom<SVGWhiteSpace>;
2285
+ readonly "word-spacing"?: MaybeReadAtom<string | number>;
2286
+ readonly "writing-mode"?: MaybeReadAtom<SVGWritingMode>;
2287
+ readonly x?: MaybeReadAtom<string | number>;
2288
+ readonly y?: MaybeReadAtom<string | number>;
2288
2289
  }
2289
2290
  interface SVGUseElementProps extends SVGGlobalProps {
2290
2291
  readonly [S_NODE_TYPE]?: SVGUseElement;
2291
2292
  readonly children?: never;
2292
- readonly "clip-path"?: MaybeReadonlyAtom<string>;
2293
- readonly "clip-rule"?: MaybeReadonlyAtom<SVGClipRule>;
2294
- readonly cursor?: MaybeReadonlyAtom<string>;
2295
- readonly height?: MaybeReadonlyAtom<string | number>;
2296
- readonly href?: MaybeReadonlyAtom<string>;
2297
- readonly mask?: MaybeReadonlyAtom<string>;
2298
- readonly opacity?: MaybeReadonlyAtom<string | number>;
2299
- readonly "pointer-events"?: MaybeReadonlyAtom<SVGPointerEvents>;
2300
- readonly requiredExtensions?: MaybeReadonlyAtom<string>;
2301
- readonly systemLanguage?: MaybeReadonlyAtom<string>;
2302
- readonly "vector-effect"?: MaybeReadonlyAtom<SVGVectorEffect>;
2303
- readonly width?: MaybeReadonlyAtom<string | number>;
2304
- readonly x?: MaybeReadonlyAtom<string | number>;
2305
- readonly y?: MaybeReadonlyAtom<string | number>;
2293
+ readonly "clip-path"?: MaybeReadAtom<string>;
2294
+ readonly "clip-rule"?: MaybeReadAtom<SVGClipRule>;
2295
+ readonly cursor?: MaybeReadAtom<string>;
2296
+ readonly height?: MaybeReadAtom<string | number>;
2297
+ readonly href?: MaybeReadAtom<string>;
2298
+ readonly mask?: MaybeReadAtom<string>;
2299
+ readonly opacity?: MaybeReadAtom<string | number>;
2300
+ readonly "pointer-events"?: MaybeReadAtom<SVGPointerEvents>;
2301
+ readonly requiredExtensions?: MaybeReadAtom<string>;
2302
+ readonly systemLanguage?: MaybeReadAtom<string>;
2303
+ readonly "vector-effect"?: MaybeReadAtom<SVGVectorEffect>;
2304
+ readonly width?: MaybeReadAtom<string | number>;
2305
+ readonly x?: MaybeReadAtom<string | number>;
2306
+ readonly y?: MaybeReadAtom<string | number>;
2306
2307
  }
2307
2308
  interface SVGViewElementProps extends SVGGlobalProps {
2308
2309
  readonly [S_NODE_TYPE]?: SVGViewElement;
2309
2310
  readonly children?: JsxChildren;
2310
- readonly preserveAspectRatio?: MaybeReadonlyAtom<string>;
2311
- readonly viewBox?: MaybeReadonlyAtom<string>;
2311
+ readonly preserveAspectRatio?: MaybeReadAtom<string>;
2312
+ readonly viewBox?: MaybeReadAtom<string>;
2312
2313
  }
2313
2314
  interface SVGIntrinsicElements {
2314
2315
  animate: SVGAnimateElementProps;
@@ -2373,12 +2374,12 @@ interface SVGIntrinsicElements {
2373
2374
  Svg: SVGSVGElementProps;
2374
2375
  }
2375
2376
  interface MathMLGlobalProps {
2376
- readonly dir?: MaybeReadonlyAtom<"rtl" | "ltr">;
2377
- readonly displaystyle?: MaybeReadonlyAtom<boolean>;
2378
- readonly mathbackground?: MaybeReadonlyAtom<string>;
2379
- readonly mathcolor?: MaybeReadonlyAtom<string>;
2380
- readonly mathsize?: MaybeReadonlyAtom<string>;
2381
- readonly scriptlevel?: MaybeReadonlyAtom<string>;
2377
+ readonly dir?: MaybeReadAtom<"rtl" | "ltr">;
2378
+ readonly displaystyle?: MaybeReadAtom<boolean>;
2379
+ readonly mathbackground?: MaybeReadAtom<string>;
2380
+ readonly mathcolor?: MaybeReadAtom<string>;
2381
+ readonly mathsize?: MaybeReadAtom<string>;
2382
+ readonly scriptlevel?: MaybeReadAtom<string>;
2382
2383
  }
2383
2384
  interface MathMLElementProps extends MathMLGlobalProps {
2384
2385
  readonly [S_NODE_TYPE]?: MathMLElement;
@@ -2387,46 +2388,46 @@ interface MathMLElementProps extends MathMLGlobalProps {
2387
2388
  interface MathMLMathElementProps extends MathMLGlobalProps {
2388
2389
  readonly [S_NODE_TYPE]?: MathMLElement;
2389
2390
  readonly children?: JsxChildren;
2390
- readonly display?: MaybeReadonlyAtom<"block" | "inline">;
2391
+ readonly display?: MaybeReadAtom<"block" | "inline">;
2391
2392
  }
2392
2393
  interface MatMLFracElementProps extends MathMLGlobalProps {
2393
2394
  readonly [S_NODE_TYPE]?: MathMLElement;
2394
2395
  readonly children?: never;
2395
- readonly linethickness?: MaybeReadonlyAtom<string>;
2396
+ readonly linethickness?: MaybeReadAtom<string>;
2396
2397
  }
2397
2398
  interface MatMLIElementProps extends MathMLGlobalProps {
2398
2399
  readonly [S_NODE_TYPE]?: MathMLElement;
2399
2400
  readonly children?: JsxChildren;
2400
- readonly mathvariant?: MaybeReadonlyAtom<"normal">;
2401
+ readonly mathvariant?: MaybeReadAtom<"normal">;
2401
2402
  }
2402
2403
  interface MatMLOElementProps extends MathMLGlobalProps {
2403
2404
  readonly [S_NODE_TYPE]?: MathMLElement;
2404
2405
  readonly children?: JsxChildren;
2405
- readonly fence?: MaybeReadonlyAtom<boolean>;
2406
- readonly form?: MaybeReadonlyAtom<"prefix" | "infix" | "postfix">;
2407
- readonly largeop?: MaybeReadonlyAtom<boolean>;
2408
- readonly lspace?: MaybeReadonlyAtom<string>;
2409
- readonly maxsize?: MaybeReadonlyAtom<string>;
2410
- readonly minsize?: MaybeReadonlyAtom<string>;
2411
- readonly movablelimits?: MaybeReadonlyAtom<boolean>;
2412
- readonly rspace?: MaybeReadonlyAtom<string>;
2413
- readonly separator?: MaybeReadonlyAtom<boolean>;
2414
- readonly stretchy?: MaybeReadonlyAtom<boolean>;
2415
- readonly symmetric?: MaybeReadonlyAtom<boolean>;
2406
+ readonly fence?: MaybeReadAtom<boolean>;
2407
+ readonly form?: MaybeReadAtom<"prefix" | "infix" | "postfix">;
2408
+ readonly largeop?: MaybeReadAtom<boolean>;
2409
+ readonly lspace?: MaybeReadAtom<string>;
2410
+ readonly maxsize?: MaybeReadAtom<string>;
2411
+ readonly minsize?: MaybeReadAtom<string>;
2412
+ readonly movablelimits?: MaybeReadAtom<boolean>;
2413
+ readonly rspace?: MaybeReadAtom<string>;
2414
+ readonly separator?: MaybeReadAtom<boolean>;
2415
+ readonly stretchy?: MaybeReadAtom<boolean>;
2416
+ readonly symmetric?: MaybeReadAtom<boolean>;
2416
2417
  }
2417
2418
  interface MatMLOverElementProps extends MathMLGlobalProps {
2418
2419
  readonly [S_NODE_TYPE]?: MathMLElement;
2419
2420
  readonly children?: JsxChildren;
2420
- readonly accent?: MaybeReadonlyAtom<boolean>;
2421
+ readonly accent?: MaybeReadAtom<boolean>;
2421
2422
  }
2422
2423
  interface MatMLPaddedElementProps extends MathMLGlobalProps {
2423
2424
  readonly [S_NODE_TYPE]?: MathMLElement;
2424
2425
  readonly children?: JsxChildren;
2425
- readonly depth?: MaybeReadonlyAtom<string>;
2426
- readonly height?: MaybeReadonlyAtom<string>;
2427
- readonly lspace?: MaybeReadonlyAtom<string>;
2428
- readonly voffset?: MaybeReadonlyAtom<string>;
2429
- readonly width?: MaybeReadonlyAtom<string>;
2426
+ readonly depth?: MaybeReadAtom<string>;
2427
+ readonly height?: MaybeReadAtom<string>;
2428
+ readonly lspace?: MaybeReadAtom<string>;
2429
+ readonly voffset?: MaybeReadAtom<string>;
2430
+ readonly width?: MaybeReadAtom<string>;
2430
2431
  }
2431
2432
  interface MatMLRowElementProps extends MathMLGlobalProps {
2432
2433
  readonly [S_NODE_TYPE]?: MathMLElement;
@@ -2435,15 +2436,15 @@ interface MatMLRowElementProps extends MathMLGlobalProps {
2435
2436
  interface MatMLSpaceElementProps extends MathMLGlobalProps {
2436
2437
  readonly [S_NODE_TYPE]?: MathMLElement;
2437
2438
  readonly children?: JsxChildren;
2438
- readonly depth?: MaybeReadonlyAtom<string>;
2439
- readonly height?: MaybeReadonlyAtom<string>;
2440
- readonly width?: MaybeReadonlyAtom<string>;
2439
+ readonly depth?: MaybeReadAtom<string>;
2440
+ readonly height?: MaybeReadAtom<string>;
2441
+ readonly width?: MaybeReadAtom<string>;
2441
2442
  }
2442
2443
  interface MatMLTDElementProps extends MathMLGlobalProps {
2443
2444
  readonly [S_NODE_TYPE]?: MathMLElement;
2444
2445
  readonly children?: JsxChildren;
2445
- readonly columnspan?: MaybeReadonlyAtom<string | number>;
2446
- readonly rowspan?: MaybeReadonlyAtom<string | number>;
2446
+ readonly columnspan?: MaybeReadAtom<string | number>;
2447
+ readonly rowspan?: MaybeReadAtom<string | number>;
2447
2448
  }
2448
2449
  interface MatMLTextElementProps extends MathMLGlobalProps {
2449
2450
  readonly [S_NODE_TYPE]?: MathMLElement;
@@ -2452,13 +2453,13 @@ interface MatMLTextElementProps extends MathMLGlobalProps {
2452
2453
  interface MatMLUnderElementProps extends MathMLGlobalProps {
2453
2454
  readonly [S_NODE_TYPE]?: MathMLElement;
2454
2455
  readonly children?: JsxChildren;
2455
- readonly accentunder?: MaybeReadonlyAtom<boolean>;
2456
+ readonly accentunder?: MaybeReadAtom<boolean>;
2456
2457
  }
2457
2458
  interface MatMLUnderOverElementProps extends MathMLGlobalProps {
2458
2459
  readonly [S_NODE_TYPE]?: MathMLElement;
2459
2460
  readonly children?: JsxChildren;
2460
- readonly accent?: MaybeReadonlyAtom<boolean>;
2461
- readonly accentunder?: MaybeReadonlyAtom<boolean>;
2461
+ readonly accent?: MaybeReadAtom<boolean>;
2462
+ readonly accentunder?: MaybeReadAtom<boolean>;
2462
2463
  }
2463
2464
  interface MathMLIntrinsicElements {
2464
2465
  merror: MathMLElementProps;
@@ -2488,14 +2489,12 @@ interface MathMLIntrinsicElements {
2488
2489
  munderover: MatMLUnderOverElementProps;
2489
2490
  MathML: MathMLMathElementProps;
2490
2491
  }
2491
- interface IntrinsicElements extends HTMLIntrinsicElements, SVGIntrinsicElements, MathMLIntrinsicElements {
2492
- a: HTMLAnchorElementProps | SVGAElementProps;
2493
- }
2492
+ interface IntrinsicElements extends HTMLIntrinsicElements, SVGIntrinsicElements, MathMLIntrinsicElements {}
2494
2493
  //#endregion
2495
2494
  //#region src/extension/AriaExtension.d.ts
2496
2495
  interface AriaExtensionType {
2497
2496
  <TExtensionKey extends string, TElements extends ElementsType>(extensionKey: TExtensionKey, elements: TElements): { [TElementName in keyof TElements]: (NodeType<TElements[TElementName]> extends Element ? TElements[TElementName] & ExtensionProps<TExtensionKey, ARIAProps> : TElements[TElementName]); };
2498
- set: (node: Element, key: keyof ARIAProps, value: MaybeReadonlyAtom<any>, group: MountingGroup<Node>) => void;
2497
+ set: (node: Element, key: keyof ARIAProps, value: MaybeReadAtom<any>, group: MountingGroup<Node>) => void;
2499
2498
  }
2500
2499
  /**
2501
2500
  * Extension adding ARIA attributes to any Element. Recommended prefix: `"aria"`
@@ -2509,8 +2508,8 @@ declare const AriaExtension: AriaExtensionType;
2509
2508
  //#endregion
2510
2509
  //#region src/extension/ClassListExtension.d.ts
2511
2510
  interface ClassListExtensionType {
2512
- <TExtensionKey extends string, TElements extends ElementsType>(extensionKey: TExtensionKey, elements: TElements): { [TElementName in keyof TElements]: (TElements[TElementName] & ExtensionProps<TExtensionKey, { readonly [TClassName in string]?: MaybeReadonlyAtom<boolean>; }>); };
2513
- set: (node: Element, className: string, toggle: MaybeReadonlyAtom<boolean>, group: MountingGroup<Node>) => void;
2511
+ <TExtensionKey extends string, TElements extends ElementsType>(extensionKey: TExtensionKey, elements: TElements): { [TElementName in keyof TElements]: (TElements[TElementName] & ExtensionProps<TExtensionKey, { readonly [TClassName in string]?: MaybeReadAtom<boolean>; }>); };
2512
+ set: (node: Element, className: string, toggle: MaybeReadAtom<boolean>, group: MountingGroup<Node>) => void;
2514
2513
  }
2515
2514
  /**
2516
2515
  * Extension adding ClassList access to any Element. Recommended prefix: `"cl"`
@@ -2532,7 +2531,7 @@ declare const ClassListExtension: ClassListExtensionType;
2532
2531
  //#region src/extension/CssStyleExtension.d.ts
2533
2532
  interface CssStyleExtensionType {
2534
2533
  <TExtensionKey extends string, TElements extends ElementsType>(extensionKey: TExtensionKey, elements: TElements): { [TElementName in keyof TElements]: (NodeType<TElements[TElementName]> extends ElementCSSInlineStyle ? TElements[TElementName] & ExtensionProps<TExtensionKey, CSSStyleDeclarationProps> : TElements[TElementName]); };
2535
- set: (node: ElementCSSInlineStyle, ruleName: string, value: MaybeReadonlyAtom<string>, group: MountingGroup<Node>) => void;
2534
+ set: (node: ElementCSSInlineStyle, ruleName: string, value: MaybeReadAtom<string>, group: MountingGroup<Node>) => void;
2536
2535
  }
2537
2536
  /**
2538
2537
  * Extension adding direct CSS rule access to any Element. Recommended prefix:
@@ -2549,8 +2548,8 @@ declare const CssStyleExtension: CssStyleExtensionType;
2549
2548
  //#endregion
2550
2549
  //#region src/extension/CssVariableExtension.d.ts
2551
2550
  interface CssVariableExtensionType {
2552
- <TExtensionKey extends string, TElements extends ElementsType>(extensionKey: TExtensionKey, elements: TElements): { [TElementName in keyof TElements]: (NodeType<TElements[TElementName]> extends ElementCSSInlineStyle ? TElements[TElementName] & ExtensionProps<TExtensionKey, { readonly [TVarName in string]?: MaybeReadonlyAtom<Nil<string | number>>; }> : TElements[TElementName]); };
2553
- set: (node: ElementCSSInlineStyle, varName: string, value: MaybeReadonlyAtom<Nil<string | number>>, group: MountingGroup<Node>) => void;
2551
+ <TExtensionKey extends string, TElements extends ElementsType>(extensionKey: TExtensionKey, elements: TElements): { [TElementName in keyof TElements]: (NodeType<TElements[TElementName]> extends ElementCSSInlineStyle ? TElements[TElementName] & ExtensionProps<TExtensionKey, { readonly [TVarName in string]?: MaybeReadAtom<Nil<string | number>>; }> : TElements[TElementName]); };
2552
+ set: (node: ElementCSSInlineStyle, varName: string, value: MaybeReadAtom<Nil<string | number>>, group: MountingGroup<Node>) => void;
2554
2553
  }
2555
2554
  /**
2556
2555
  * Extension adding CSS variable access to any Element. Recommended prefix:
@@ -2571,8 +2570,8 @@ declare const CssVariableExtension: CssVariableExtensionType;
2571
2570
  //#endregion
2572
2571
  //#region src/extension/DatasetExtension.d.ts
2573
2572
  interface DatasetExtensionType {
2574
- <TExtensionKey extends string, TElements extends ElementsType>(extensionKey: TExtensionKey, elements: TElements): { [TElementName in keyof TElements]: (NodeType<TElements[TElementName]> extends HTMLOrSVGElement ? TElements[TElementName] & ExtensionProps<TExtensionKey, { readonly [TKey in string]?: MaybeReadonlyAtom<string | undefined>; }> : TElements[TElementName]); };
2575
- set: (node: HTMLOrSVGElement, key: string, value: MaybeReadonlyAtom<string | undefined>, group: MountingGroup<Node>) => void;
2573
+ <TExtensionKey extends string, TElements extends ElementsType>(extensionKey: TExtensionKey, elements: TElements): { [TElementName in keyof TElements]: (NodeType<TElements[TElementName]> extends HTMLOrSVGElement ? TElements[TElementName] & ExtensionProps<TExtensionKey, { readonly [TKey in string]?: MaybeReadAtom<string | undefined>; }> : TElements[TElementName]); };
2574
+ set: (node: HTMLOrSVGElement, key: string, value: MaybeReadAtom<string | undefined>, group: MountingGroup<Node>) => void;
2576
2575
  }
2577
2576
  /**
2578
2577
  * Extension adding dataset access to any HTML or SVG element. Recommended
@@ -2594,15 +2593,12 @@ interface EventExtensionType {
2594
2593
  <TExtensionKey extends string, TElements extends ElementsType>(extensionKey: TExtensionKey, elements: TElements): { [TElementName in keyof TElements]: (TElements[TElementName] & ExtensionProps<TExtensionKey, { readonly [TEventName in keyof GlobalEventHandlersEventMap]?: EventListenerType<GlobalEventHandlersEventMap[TEventName], NodeType<TElements[TElementName]>, TEventName>; }>); };
2595
2594
  set: (node: HTMLElement, className: string, toggle: EventListenerType<unknown, unknown, string>) => void;
2596
2595
  }
2597
- type EventListenerType<TEvent, TNode = EventTarget, TEventName = string> = MaybeReadonlyAtom<Nil<(e: ExtendedEvent<TEvent, TNode, TEventName>) => void>> | (AddEventListenerOptions & {
2598
- capture?: false;
2599
- } & {
2600
- readonly listener: MaybeReadonlyAtom<Nil<(e: ExtendedEvent<TEvent, TNode, TEventName>) => void>>;
2601
- }) | (AddEventListenerOptions & {
2602
- capture: true;
2603
- } & {
2604
- readonly listener: MaybeReadonlyAtom<Nil<(e: ExtendedEvent<TEvent, EventTarget | null, TEventName>) => void>>;
2605
- });
2596
+ type EventListenerType<TEvent, TNode = EventTarget, TEventName = string> = MaybeReadAtom<Nil<(e: ExtendedEvent<TEvent, TNode, TEventName>) => void>> | {
2597
+ readonly capture?: boolean;
2598
+ readonly once?: boolean;
2599
+ readonly passive?: boolean;
2600
+ readonly listener: MaybeReadAtom<Nil<(e: ExtendedEvent<TEvent, TNode, TEventName>) => void>>;
2601
+ };
2606
2602
  type ExtendedEvent<TEvent, TNode = EventTarget, TEventName = string> = Omit<TEvent, "type" | "currentTarget"> & {
2607
2603
  readonly currentTarget: TNode;
2608
2604
  readonly type: TEventName;