@slotted/react 0.0.0-stage → 0.1.0-beta.0

package/dist/types/typography/heading.d.ts

@@ -0,0 +1,293 @@
+
+import type { HeadingProps } from './typography.types';
+/**
+ * A heading is a rank in the document outline and a size on the page, and the
+ * two are separate: `level` decides the element, `size` decides how it reads.
+ * Left alone, the size follows the rank, so the common case needs no decision.
+ */
+export declare function Heading({ align, level, numeric, size, style, tone, transform, truncate, weight, wrap, ...nativeProps }: HeadingProps): import("react").DetailedReactHTMLElement<{
+    'data-part': string;
+    'data-ui': string;
+    style: import("react").CSSProperties | undefined;
+    children?: import("react").ReactNode;
+    slot?: string | undefined | undefined;
+    title?: string | undefined | undefined;
+    defaultValue?: string | number | readonly string[] | undefined;
+    key?: import("react").Key | null | undefined;
+    defaultChecked?: boolean | undefined | undefined;
+    suppressContentEditableWarning?: boolean | undefined | undefined;
+    suppressHydrationWarning?: boolean | undefined | undefined;
+    accessKey?: string | undefined | undefined;
+    autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {}) | undefined;
+    autoFocus?: boolean | undefined | undefined;
+    className?: string | undefined | undefined;
+    contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+    contextMenu?: string | undefined | undefined;
+    dir?: string | undefined | undefined;
+    draggable?: (boolean | "true" | "false") | undefined;
+    enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined | undefined;
+    hidden?: boolean | undefined | undefined;
+    id?: string | undefined | undefined;
+    lang?: string | undefined | undefined;
+    nonce?: string | undefined | undefined;
+    spellCheck?: (boolean | "true" | "false") | undefined;
+    tabIndex?: number | undefined | undefined;
+    translate?: "yes" | "no" | undefined | undefined;
+    radioGroup?: string | undefined | undefined;
+    role?: import("react").AriaRole | undefined;
+    about?: string | undefined | undefined;
+    content?: string | undefined | undefined;
+    datatype?: string | undefined | undefined;
+    inlist?: any;
+    prefix?: string | undefined | undefined;
+    property?: string | undefined | undefined;
+    rel?: string | undefined | undefined;
+    resource?: string | undefined | undefined;
+    rev?: string | undefined | undefined;
+    typeof?: string | undefined | undefined;
+    vocab?: string | undefined | undefined;
+    autoCorrect?: string | undefined | undefined;
+    autoSave?: string | undefined | undefined;
+    color?: string | undefined | undefined;
+    itemProp?: string | undefined | undefined;
+    itemScope?: boolean | undefined | undefined;
+    itemType?: string | undefined | undefined;
+    itemID?: string | undefined | undefined;
+    itemRef?: string | undefined | undefined;
+    results?: number | undefined | undefined;
+    security?: string | undefined | undefined;
+    unselectable?: "on" | "off" | undefined | undefined;
+    popover?: "" | "auto" | "manual" | "hint" | undefined | undefined;
+    popoverTargetAction?: "toggle" | "show" | "hide" | undefined | undefined;
+    popoverTarget?: string | undefined | undefined;
+    inert?: boolean | undefined | undefined;
+    inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined | undefined;
+    is?: string | undefined | undefined;
+    exportparts?: string | undefined | undefined;
+    part?: string | undefined | undefined;
+    "aria-activedescendant"?: string | undefined | undefined;
+    "aria-atomic"?: (boolean | "true" | "false") | undefined;
+    "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined | undefined;
+    "aria-braillelabel"?: string | undefined | undefined;
+    "aria-brailleroledescription"?: string | undefined | undefined;
+    "aria-busy"?: (boolean | "true" | "false") | undefined;
+    "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+    "aria-colcount"?: number | undefined | undefined;
+    "aria-colindex"?: number | undefined | undefined;
+    "aria-colindextext"?: string | undefined | undefined;
+    "aria-colspan"?: number | undefined | undefined;
+    "aria-controls"?: string | undefined | undefined;
+    "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined | undefined;
+    "aria-describedby"?: string | undefined | undefined;
+    "aria-description"?: string | undefined | undefined;
+    "aria-details"?: string | undefined | undefined;
+    "aria-disabled"?: (boolean | "true" | "false") | undefined;
+    "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined | undefined;
+    "aria-errormessage"?: string | undefined | undefined;
+    "aria-expanded"?: (boolean | "true" | "false") | undefined;
+    "aria-flowto"?: string | undefined | undefined;
+    "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+    "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined | undefined;
+    "aria-hidden"?: (boolean | "true" | "false") | undefined;
+    "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined | undefined;
+    "aria-keyshortcuts"?: string | undefined | undefined;
+    "aria-label"?: string | undefined | undefined;
+    "aria-labelledby"?: string | undefined | undefined;
+    "aria-level"?: number | undefined | undefined;
+    "aria-live"?: "off" | "assertive" | "polite" | undefined | undefined;
+    "aria-modal"?: (boolean | "true" | "false") | undefined;
+    "aria-multiline"?: (boolean | "true" | "false") | undefined;
+    "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+    "aria-orientation"?: "horizontal" | "vertical" | undefined | undefined;
+    "aria-owns"?: string | undefined | undefined;
+    "aria-placeholder"?: string | undefined | undefined;
+    "aria-posinset"?: number | undefined | undefined;
+    "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+    "aria-readonly"?: (boolean | "true" | "false") | undefined;
+    "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined | undefined;
+    "aria-required"?: (boolean | "true" | "false") | undefined;
+    "aria-roledescription"?: string | undefined | undefined;
+    "aria-rowcount"?: number | undefined | undefined;
+    "aria-rowindex"?: number | undefined | undefined;
+    "aria-rowindextext"?: string | undefined | undefined;
+    "aria-rowspan"?: number | undefined | undefined;
+    "aria-selected"?: (boolean | "true" | "false") | undefined;
+    "aria-setsize"?: number | undefined | undefined;
+    "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined | undefined;
+    "aria-valuemax"?: number | undefined | undefined;
+    "aria-valuemin"?: number | undefined | undefined;
+    "aria-valuenow"?: number | undefined | undefined;
+    "aria-valuetext"?: string | undefined | undefined;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    } | undefined | undefined;
+    onCopy?: import("react").ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onCopyCapture?: import("react").ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onCut?: import("react").ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onCutCapture?: import("react").ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onPaste?: import("react").ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onPasteCapture?: import("react").ClipboardEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionEnd?: import("react").CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionStart?: import("react").CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionUpdate?: import("react").CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLHeadingElement> | undefined;
+    onFocus?: import("react").FocusEventHandler<HTMLHeadingElement> | undefined;
+    onFocusCapture?: import("react").FocusEventHandler<HTMLHeadingElement> | undefined;
+    onBlur?: import("react").FocusEventHandler<HTMLHeadingElement> | undefined;
+    onBlurCapture?: import("react").FocusEventHandler<HTMLHeadingElement> | undefined;
+    onChange?: import("react").ChangeEventHandler<HTMLHeadingElement, Element> | undefined;
+    onChangeCapture?: import("react").ChangeEventHandler<HTMLHeadingElement, Element> | undefined;
+    onBeforeInput?: import("react").InputEventHandler<HTMLHeadingElement> | undefined;
+    onBeforeInputCapture?: import("react").InputEventHandler<HTMLHeadingElement> | undefined;
+    onInput?: import("react").InputEventHandler<HTMLHeadingElement> | undefined;
+    onInputCapture?: import("react").InputEventHandler<HTMLHeadingElement> | undefined;
+    onReset?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onResetCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSubmit?: import("react").SubmitEventHandler<HTMLHeadingElement> | undefined;
+    onSubmitCapture?: import("react").SubmitEventHandler<HTMLHeadingElement> | undefined;
+    onInvalid?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onInvalidCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoad?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onError?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onErrorCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onKeyDown?: import("react").KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onKeyPress?: import("react").KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onKeyUp?: import("react").KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLHeadingElement> | undefined;
+    onAbort?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onAbortCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onCanPlay?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onCanPlayCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onCanPlayThrough?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onDurationChange?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onDurationChangeCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEmptied?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEmptiedCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEncrypted?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEncryptedCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEnded?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onEndedCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadedData?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadedDataCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadedMetadata?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadStart?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onLoadStartCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPause?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPauseCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPlay?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPlayCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPlaying?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onPlayingCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onProgress?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onProgressCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onRateChange?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onRateChangeCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSeeked?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSeekedCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSeeking?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSeekingCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onStalled?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onStalledCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSuspend?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSuspendCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onTimeUpdate?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onVolumeChange?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onWaiting?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onWaitingCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onAuxClick?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onAuxClickCapture?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onClick?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onClickCapture?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onContextMenu?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onContextMenuCapture?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onDoubleClick?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onDoubleClickCapture?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onDrag?: import("react").DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragCapture?: import("react").DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragEnd?: import("react").DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragEndCapture?: import("react").DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragEnter?: import("react").DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragEnterCapture?: import("react").DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragExit?: import("react").DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragExitCapture?: import("react").DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragLeave?: import("react").DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragLeaveCapture?: import("react").DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragOver?: import("react").DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragOverCapture?: import("react").DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragStart?: import("react").DragEventHandler<HTMLHeadingElement> | undefined;
+    onDragStartCapture?: import("react").DragEventHandler<HTMLHeadingElement> | undefined;
+    onDrop?: import("react").DragEventHandler<HTMLHeadingElement> | undefined;
+    onDropCapture?: import("react").DragEventHandler<HTMLHeadingElement> | undefined;
+    onMouseDown?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseDownCapture?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseEnter?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseLeave?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseMove?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseMoveCapture?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseOut?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseOutCapture?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseOver?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseOverCapture?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseUp?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onMouseUpCapture?: import("react").MouseEventHandler<HTMLHeadingElement> | undefined;
+    onSelect?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onSelectCapture?: import("react").ReactEventHandler<HTMLHeadingElement> | undefined;
+    onTouchCancel?: import("react").TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchCancelCapture?: import("react").TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchEnd?: import("react").TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchEndCapture?: import("react").TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchMove?: import("react").TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchMoveCapture?: import("react").TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchStart?: import("react").TouchEventHandler<HTMLHeadingElement> | undefined;
+    onTouchStartCapture?: import("react").TouchEventHandler<HTMLHeadingElement> | undefined;
+    onPointerDown?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerDownCapture?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerMove?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerMoveCapture?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerUp?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerUpCapture?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerCancel?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerCancelCapture?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerEnter?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerLeave?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerOver?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerOverCapture?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerOut?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onPointerOutCapture?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onGotPointerCapture?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onLostPointerCapture?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLHeadingElement> | undefined;
+    onScroll?: import("react").UIEventHandler<HTMLHeadingElement> | undefined;
+    onScrollCapture?: import("react").UIEventHandler<HTMLHeadingElement> | undefined;
+    onScrollEnd?: import("react").UIEventHandler<HTMLHeadingElement> | undefined;
+    onScrollEndCapture?: import("react").UIEventHandler<HTMLHeadingElement> | undefined;
+    onWheel?: import("react").WheelEventHandler<HTMLHeadingElement> | undefined;
+    onWheelCapture?: import("react").WheelEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationStart?: import("react").AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationEnd?: import("react").AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationIteration?: import("react").AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLHeadingElement> | undefined;
+    onToggle?: import("react").ToggleEventHandler<HTMLHeadingElement> | undefined;
+    onBeforeToggle?: import("react").ToggleEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionCancel?: import("react").TransitionEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionCancelCapture?: import("react").TransitionEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionEnd?: import("react").TransitionEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionRun?: import("react").TransitionEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionRunCapture?: import("react").TransitionEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionStart?: import("react").TransitionEventHandler<HTMLHeadingElement> | undefined;
+    onTransitionStartCapture?: import("react").TransitionEventHandler<HTMLHeadingElement> | undefined;
+}, HTMLElement>;
+//# sourceMappingURL=heading.d.ts.map

package/dist/types/typography/heading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heading.d.ts","sourceRoot":"","sources":["../../../src/typography/heading.tsx"],"names":[],"mappings":"AAAA,OAAO,2CAA2C,CAAC;AAMnD,OAAO,KAAK,EAAE,YAAY,EAAqC,MAAM,oBAAoB,CAAC;AAc1F;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,EACtB,KAAK,EACL,KAAK,EACL,OAAO,EACP,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,SAAS,EACT,QAAQ,EACR,MAAmB,EACnB,IAAgB,EAChB,GAAG,WAAW,EACf,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA+Bd"}

package/dist/types/typography/index.d.ts

@@ -0,0 +1,5 @@
+export { Heading } from './heading';
+export { HeadingLevel, useHeadingLevel } from './heading-level';
+export { Text } from './text';
+export type { HeadingLevelProps, HeadingLevelValue, HeadingProps, TextProps, TypographyAlign, TypographyAxes, TypographyNumeric, TypographyRootProps, TypographySize, TypographyTone, TypographyTransform, TypographyWeight, TypographyWrap, } from './typography.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/typography/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/typography/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,YAAY,EACV,iBAAiB,EACjB,iBAAiB,EACjB,YAAY,EACZ,SAAS,EACT,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,GACf,MAAM,oBAAoB,CAAC"}

package/dist/types/typography/text.d.ts

@@ -0,0 +1,12 @@
+
+import type { TextProps } from './typography.types';
+/**
+ * Text sets the library's type on whatever element the consumer means. The
+ * default is a span, which claims nothing: a paragraph, a label or a table
+ * cell is a claim the consumer makes, through `render`.
+ *
+ * Colour is inherited rather than painted, so text on a tonal surface reads
+ * that surface until `tone` asks for something else.
+ */
+export declare function Text({ align, numeric, render, size, style, tone, transform, truncate, weight, wrap, ...nativeProps }: TextProps): string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+//# sourceMappingURL=text.d.ts.map

package/dist/types/typography/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/typography/text.tsx"],"names":[],"mappings":"AAAA,OAAO,2CAA2C,CAAC;AAGnD,OAAO,KAAK,EAAE,SAAS,EAAuB,MAAM,oBAAoB,CAAC;AAEzE;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,EACnB,KAAK,EACL,OAAO,EACP,MAAM,EACN,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,SAAS,EACT,QAAQ,EACR,MAAM,EACN,IAAI,EACJ,GAAG,WAAW,EACf,EAAE,SAAS,+VAUX"}

package/dist/types/typography/typography.attributes.d.ts

@@ -0,0 +1,18 @@
+import type { CSSProperties } from 'react';
+import type { TypographyAxes } from './typography.types';
+/**
+ * An axis reaches the stylesheet only when someone decided it. The base rule
+ * already paints the family default, and text is the most numerous element in
+ * any document: restating that default on every one of them would be seven
+ * attributes of noise per paragraph.
+ *
+ * `tone: 'inherit'` is the absence of a colour rather than a colour, so it
+ * writes nothing at all.
+ */
+export declare function axisAttributes(axes: TypographyAxes): Record<string, string>;
+/**
+ * A line count cannot be read from an attribute by CSS, so it travels as a
+ * custom property. The consumer's own style still wins the properties it sets.
+ */
+export declare function truncationStyle(truncate: TypographyAxes['truncate'], style: CSSProperties | undefined): CSSProperties | undefined;
+//# sourceMappingURL=typography.attributes.d.ts.map

package/dist/types/typography/typography.attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typography.attributes.d.ts","sourceRoot":"","sources":["../../../src/typography/typography.attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAE3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAUzD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAc3E;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,EACpC,KAAK,EAAE,aAAa,GAAG,SAAS,GAC/B,aAAa,GAAG,SAAS,CAI3B"}

package/dist/types/typography/typography.types.d.ts

@@ -0,0 +1,49 @@
+import type { ComponentPropsWithoutRef, CSSProperties, HTMLAttributes, ReactNode } from 'react';
+export type TypographySize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
+export type TypographyWeight = 'regular' | 'medium' | 'semibold';
+export type TypographyTone = 'inherit' | 'default' | 'muted' | 'accent' | 'success' | 'warning' | 'danger' | 'inverse';
+export type TypographyAlign = 'start' | 'center' | 'end';
+export type TypographyWrap = 'normal' | 'nowrap' | 'balance' | 'pretty';
+export type TypographyTransform = 'none' | 'uppercase' | 'capitalize';
+export type TypographyNumeric = 'normal' | 'tabular';
+/** The six the platform has. A seventh would be a heading no browser knows. */
+export type HeadingLevelValue = 1 | 2 | 3 | 4 | 5 | 6;
+export interface TypographyAxes {
+    /**
+     * Alignment needs a box to align inside, so asking for it turns the default
+     * inline element into a block.
+     */
+    align?: TypographyAlign | undefined;
+    numeric?: TypographyNumeric | undefined;
+    size?: TypographySize | undefined;
+    /** `inherit` takes the colour of whatever contains the text. */
+    tone?: TypographyTone | undefined;
+    transform?: TypographyTransform | undefined;
+    /**
+     * `true` keeps one line, a number keeps that many. The whole string stays in
+     * the document either way: only the picture is shorter.
+     */
+    truncate?: boolean | number | undefined;
+    weight?: TypographyWeight | undefined;
+    wrap?: TypographyWrap | undefined;
+}
+export interface TypographyRootProps extends HTMLAttributes<HTMLElement> {
+    'data-part': string;
+    'data-ui': string;
+    style?: CSSProperties | undefined;
+}
+export interface TextProps extends ComponentPropsWithoutRef<'span'>, TypographyAxes {
+    /** Renders the wiring into another element when a span is the wrong claim. */
+    render?: ((props: TypographyRootProps) => ReactNode) | undefined;
+}
+export interface HeadingProps extends ComponentPropsWithoutRef<'h2'>, TypographyAxes {
+    /**
+     * The rank of the heading, which decides the element. Left out, the heading
+     * takes the level its section provides.
+     */
+    level?: HeadingLevelValue | undefined;
+}
+export interface HeadingLevelProps {
+    children?: ReactNode | undefined;
+}
+//# sourceMappingURL=typography.types.d.ts.map

package/dist/types/typography/typography.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typography.types.d.ts","sourceRoot":"","sources":["../../../src/typography/typography.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,aAAa,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEhG,MAAM,MAAM,cAAc,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,CAAC;AAC9E,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,QAAQ,GAAG,UAAU,CAAC;AACjE,MAAM,MAAM,cAAc,GACxB,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAC5F,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC;AACzD,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;AACxE,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,WAAW,GAAG,YAAY,CAAC;AACtE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,SAAS,CAAC;AAErD,+EAA+E;AAC/E,MAAM,MAAM,iBAAiB,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEtD,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,KAAK,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC;IACpC,OAAO,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACxC,IAAI,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IAClC,gEAAgE;IAChE,IAAI,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IAClC,SAAS,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;IAC5C;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;IACxC,MAAM,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;IACtC,IAAI,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;CACnC;AAED,MAAM,WAAW,mBAAoB,SAAQ,cAAc,CAAC,WAAW,CAAC;IACtE,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;CACnC;AAED,MAAM,WAAW,SAAU,SAAQ,wBAAwB,CAAC,MAAM,CAAC,EAAE,cAAc;IACjF,8EAA8E;IAC9E,MAAM,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,mBAAmB,KAAK,SAAS,CAAC,GAAG,SAAS,CAAC;CAClE;AAED,MAAM,WAAW,YAAa,SAAQ,wBAAwB,CAAC,IAAI,CAAC,EAAE,cAAc;IAClF;;;OAGG;IACH,KAAK,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;CACvC;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;CAClC"}

package/dist/types/upload/index.d.ts

@@ -0,0 +1,4 @@
+export { Upload } from './upload';
+export { UploadDefaultsProvider, useUploadDefaults } from './upload-defaults';
+export type { DuplicatePolicy, FileKind, UploadDefaults, UploadDefaultsProviderProps, UploadFile, UploadFilesReason, UploadHandle, UploadLayout, UploadPreview, UploadProps, UploadRejectionReason, UploadRootProps, UploadSize, UploadVariant, UploadView, UploadViewingReason, } from './upload.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/upload/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/upload/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC9E,YAAY,EACV,eAAe,EACf,QAAQ,EACR,cAAc,EACd,2BAA2B,EAC3B,UAAU,EACV,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,WAAW,EACX,qBAAqB,EACrB,eAAe,EACf,UAAU,EACV,aAAa,EACb,UAAU,EACV,mBAAmB,GACpB,MAAM,gBAAgB,CAAC"}

package/dist/types/upload/upload-defaults.d.ts

@@ -0,0 +1,20 @@
+import type { UploadDefaults, UploadDefaultsProviderProps } from './upload.types';
+/** What an upload does here, before it states anything of its own. */
+export declare function useUploadDefaults(): UploadDefaults;
+/**
+ * An application decides once what its uploads accept, where they send and how
+ * many run at once. A control that states any of them itself still wins. Every
+ * word and the locale that writes sizes and durations come from the language
+ * in force (`SlottedProvider`).
+ *
+ * The adapter is here rather than on the family for the same reason: an
+ * application sends to one place, and repeating the sender on every form is how
+ * one of them ends up pointing somewhere else.
+ */
+export declare function UploadDefaultsProvider({ children, ...defaults }: UploadDefaultsProviderProps): import("react").JSX.Element;
+/** The two formatters a row and a summary read, bound to one locale. */
+export declare function useUploadFormatters(locale: string): {
+    bytes: (value: number) => string;
+    duration: (seconds: number) => string;
+};
+//# sourceMappingURL=upload-defaults.d.ts.map

package/dist/types/upload/upload-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-defaults.d.ts","sourceRoot":"","sources":["../../../src/upload/upload-defaults.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC;AA0BlF,sEAAsE;AACtE,wBAAgB,iBAAiB,IAAI,cAAc,CAElD;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,EAAE,2BAA2B,+BAe5F;AAED,wEAAwE;AACxE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM;mBAE/B,MAAM;wBACD,MAAM;EAE7B"}

package/dist/types/upload/upload-demo.d.ts

@@ -0,0 +1,138 @@
+import type { UploadAdapter, UploadFile, UploadStatus } from '@slotted/core/upload';
+import type { UploadProps } from './upload.types';
+/**
+ * What the reference page needs and an application does not: files that exist
+ * without a picker, and a sender that behaves like a network without being one.
+ *
+ * Every demonstration on the page is a live upload — the same component, the
+ * same rules, the same DOM — against these two. Nothing here is drawn by hand.
+ */
+/** One claim, throughout the page. Real names, real sizes, real kinds. */
+export interface DemoSeed {
+    name: string;
+    size: number;
+    type: string;
+    status?: UploadStatus;
+    loaded?: number;
+    reason?: UploadFile['reason'];
+}
+/**
+ * A real `File`, so the family behaves exactly as it does in an application:
+ * the object URL is real, the thumbnail is real, and the adapter is handed
+ * something it could actually send.
+ */
+export declare function demoFile({ name, size, type }: DemoSeed): File;
+export declare function demoEntry(seed: DemoSeed): UploadFile;
+/**
+ * A sender that moves bytes at a stated rate rather than instantly, so the bar,
+ * the percentage, the remaining time and the concurrency limit are all readable
+ * on a page nobody has to click through.
+ */
+export declare function demoAdapter({ bytesPerSecond, fails, pausable, stalls, }?: {
+    bytesPerSecond?: number;
+    fails?: boolean;
+    pausable?: boolean;
+    stalls?: boolean;
+}): UploadAdapter;
+/**
+ * The family, holding its own list, seeded with files that are already in the
+ * state the scene is about. It is controlled so that a scene can start at
+ * `error` or `paused` without waiting for one to happen.
+ */
+export declare function DemoUpload({ seed, ...props }: Omit<UploadProps, 'files' | 'defaultFiles' | 'onFilesChange'> & {
+    seed?: readonly DemoSeed[];
+}): import("react").JSX.Element;
+/** The claim every demonstration on this page is about. */
+export declare const CLAIM: {
+    form: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    notes: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    estimate: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    review: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    front: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    rear: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    airbag: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    dashcam: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    call: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    archive: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    police: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    medical: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    witness: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    garage: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    logbook: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    unnamed: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    long: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    arabic: {
+        name: string;
+        size: number;
+        type: string;
+    };
+};
+//# sourceMappingURL=upload-demo.d.ts.map

package/dist/types/upload/upload-demo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-demo.d.ts","sourceRoot":"","sources":["../../../src/upload/upload-demo.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAIpF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD;;;;;;GAMG;AAEH,0EAA0E;AAC1E,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC;CAC/B;AA4FD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,QAAQ,GAAG,IAAI,CAQ7D;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,CAgBpD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAC1B,cAAwB,EACxB,KAAa,EACb,QAAgB,EAChB,MAAc,GACf,GAAE;IACD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;CACb,GAAG,aAAa,CAoBrB;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,EACzB,IAAS,EACT,GAAG,KAAK,EACT,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,cAAc,GAAG,eAAe,CAAC,GAAG;IAAE,IAAI,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAA;CAAE,+BAKhG;AAED,2DAA2D;AAC3D,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCkB,CAAC"}

package/dist/types/upload/upload-viewer.d.ts

@@ -0,0 +1,34 @@
+import type { FamilyTranslator, UploadMessages } from '@slotted/core/i18n';
+import type { FileKind, UploadFile } from '@slotted/core/upload';
+import type { GlyphName } from '../icon';
+import type { UploadFormatters } from './upload.types';
+/**
+ * A file, full screen, on a surface of its own.
+ *
+ * `dialog` owns the layer, the scrim, the focus containment, the scroll lock
+ * and Escape; what this owns is the stage, the header and the two controls that
+ * move through the set. A preview that left the page was the first answer and
+ * it was the wrong one — it loses the form the reader was in the middle of
+ * filling in. The tab survives as the escape hatch in the header, where a PDF is
+ * better read in the browser's own full window.
+ */
+export interface UploadViewerProps {
+    files: readonly UploadFile[];
+    /** The family's size, restated on the layer: it is portalled out of the root. */
+    size: 'sm' | 'md' | 'lg';
+    /** The key of the file being looked at, or `null` when the viewer is shut. */
+    viewing: string | null;
+    urls: ReadonlyMap<string, string>;
+    /** The family's words, the same translator the root reads. */
+    t: FamilyTranslator<UploadMessages>;
+    formatters: UploadFormatters;
+    onViewing: (key: string | null, reason: 'pointer' | 'keyboard' | 'escape' | 'outsidePress' | 'dismiss', source: unknown) => void;
+}
+export declare function UploadViewer({ files, size, viewing, urls, t, formatters, onViewing, }: UploadViewerProps): import("react").JSX.Element;
+/**
+ * What a file is drawn as on its tile: one glyph per kind, the plain file for
+ * anything no kind claims. The row's tile and the viewer's stage read the same
+ * map, so a kind never has two marks.
+ */
+export declare const KIND_GLYPH: Record<FileKind, GlyphName>;
+//# sourceMappingURL=upload-viewer.d.ts.map

package/dist/types/upload/upload-viewer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-viewer.d.ts","sourceRoot":"","sources":["../../../src/upload/upload-viewer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAG3E,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAKjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD;;;;;;;;;GASG;AAEH,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;IAC7B,iFAAiF;IACjF,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;IACzB,8EAA8E;IAC9E,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,8DAA8D;IAC9D,CAAC,EAAE,gBAAgB,CAAC,cAAc,CAAC,CAAC;IACpC,UAAU,EAAE,gBAAgB,CAAC;IAC7B,SAAS,EAAE,CACT,GAAG,EAAE,MAAM,GAAG,IAAI,EAClB,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,QAAQ,GAAG,cAAc,GAAG,SAAS,EACtE,MAAM,EAAE,OAAO,KACZ,IAAI,CAAC;CACX;AAED,wBAAgB,YAAY,CAAC,EAC3B,KAAK,EACL,IAAI,EACJ,OAAO,EACP,IAAI,EACJ,CAAC,EACD,UAAU,EACV,SAAS,GACV,EAAE,iBAAiB,+BAsLnB;AA4DD;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,QAAQ,EAAE,SAAS,CAUlD,CAAC"}