@pharos-ds/core 0.1.9

package/dist/TimeInput/TimeInput.js

@@ -0,0 +1,423 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+'use client';
+
+/**
+ * @file TimeInput.tsx
+ * @input Uses React, useId, useState, useCallback, useRef, Field, Icon, InputGroupContext, useAnnounce
+ * @output Exports TimeInput component, TimeInputProps
+ * @position Core implementation; consumed by index.ts, tested by TimeInput.test.tsx
+ *
+ * SYNC: When modified, update these files to stay in sync:
+ * - /packages/core/src/TimeInput/TimeInput.doc.mjs (props table, features, implementation notes)
+ * - /packages/core/src/TimeInput/TimeInput.test.tsx (tests for new/changed behavior)
+ * - /packages/core/src/TimeInput/index.ts (exports if types change)
+ * - /apps/storybook/stories/TimeInput.stories.tsx (storybook stories)
+ * - /packages/cli/templates/blocks/components/TimeInput/ (showcase blocks)
+ */
+import { useId, useState, useCallback, useEffect, useRef, useMemo, useOptimistic, useTransition } from 'react';
+import * as stylex from '@stylexjs/stylex';
+import "../theme/tokens.stylex.js";
+import { colorVars, sizeVars, radiusVars, typographyVars, typeScaleVars, borderVars } from "../theme/tokens.stylex.js";
+import { Field, inputWrapperStyles, inputStatusBorderStyles, inputStatusHoverShadowStyles, inputStatusFocusWithinStyles } from "../Field/index.js";
+import { Icon } from "../Icon/index.js";
+import { Spinner } from "../Spinner/index.js";
+import { VisuallyHidden } from "../VisuallyHidden/index.js";
+import { parseTimeInput, formatDisplayTime12h, formatDisplayTime24h, formatISOTime, adjustTime, isTimeInRange, mergeProps, mergeRefs, getInputARIA } from "../utils/index.js";
+import { useSize } from "../SizeContext/SizeContext.js";
+import { useAnnounce } from "../hooks/useAnnounce.js";
+import { useInputContainer } from "../hooks/useInputContainer.js";
+import { useInputStatusIcon } from "../hooks/useInputStatusIcon.js";
+import { useInputGroup } from "../InputGroup/InputGroupContext.js";
+import { groupStyles } from "../InputGroup/groupStyles.js";
+import { useTooltip } from "../Tooltip/index.js";
+import { themeProps } from "../utils/themeProps.js";
+import { useTranslator } from "../i18n/index.js";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+const sizeStyles = {
+  sm: {
+    kZKoxP: "x6k0iem",
+    k7Eaqz: "x1i9suas",
+    $$css: true
+  },
+  md: {
+    kZKoxP: "x1ueg155",
+    k7Eaqz: "x1i9suas",
+    $$css: true
+  },
+  lg: {
+    kZKoxP: "xssyfek",
+    k7Eaqz: "x1i9suas",
+    $$css: true
+  }
+};
+
+// Re-export shared types for convenience
+
+/**
+ * A time input component with text input and keyboard navigation.
+ *
+ * @example
+ * ```
+ * <TimeInput
+ *   label="Start time"
+ *   value={time}
+ *   onChange={setTime}
+ *   hourFormat="12h"
+ *   hasClear
+ * />
+ * ```
+ */
+export function TimeInput({
+  label,
+  isLabelHidden = false,
+  description,
+  isOptional = false,
+  isRequired = false,
+  isDisabled = false,
+  disabledMessage,
+  value,
+  onChange,
+  changeAction,
+  isLoading = false,
+  min,
+  max,
+  hasSeconds = false,
+  hasClear = false,
+  hasAutoFocus = false,
+  hourFormat = '12h',
+  increment = 1,
+  placeholder: placeholderFromProps,
+  size: sizeProp,
+  status,
+  statusVariant = 'attached',
+  labelTooltip,
+  width,
+  xstyle,
+  className,
+  style,
+  ref
+}) {
+  const t = useTranslator();
+  const placeholder = placeholderFromProps ?? t('@pharos.timeInput.placeholder');
+  const size = useSize(sizeProp, 'md');
+  const id = useId();
+  const inputLabelID = useId();
+  const descriptionID = useId();
+  const statusMessageID = useId();
+  const inputRef = useRef(null);
+  const containerRef = useRef(null);
+  const inputGroup = useInputGroup();
+  const [, startTransition] = useTransition();
+  const [optimisticValue, setOptimisticValue] = useOptimistic(value);
+  const isBusy = isLoading || optimisticValue !== value;
+
+  // In grouped mode the status message renders as a visually-hidden node that
+  // exists only for aria-describedby. Announce it through the persistent
+  // useAnnounce live regions instead of role/aria-live on that node — a live
+  // region mounted together with its content is not reliably announced.
+  // Ungrouped mode delegates to Field -> FieldStatus, which announces itself.
+  const announce = useAnnounce();
+  useEffect(() => {
+    if (inputGroup && status?.message) {
+      announce(status.message, status.type === 'error' ? 'assertive' : 'polite');
+    }
+  }, [announce, inputGroup, status?.message, status?.type]);
+
+  // Disabled-reason tooltip. Disabled controls swallow pointer events, so the
+  // tooltip listeners attach to the input container (which already exists) and
+  // the input stays perceivable via aria-disabled instead of the disabled
+  // attribute. Typing is blocked with readOnly and value mutation guards.
+  const showsDisabledMessage = isDisabled && !!disabledMessage;
+  const disabledMessageTooltip = useTooltip({
+    placement: 'above',
+    // The container div is not naturally focusable; focusin bubbles up from
+    // the input, so always attach focus listeners.
+    focusTrigger: 'always',
+    isEnabled: showsDisabledMessage
+  });
+
+  // Status icon mapping
+  const {
+    statusIcon,
+    describedBy: statusTooltipDescribedBy
+  } = useInputStatusIcon({
+    status,
+    statusVariant,
+    isInGroup: !!inputGroup
+  });
+  const {
+    ariaLabelledBy,
+    ariaDescribedBy
+  } = getInputARIA(inputLabelID, [description ? descriptionID : null, statusVariant !== 'tooltip' && status?.message ? statusMessageID : null,
+  // The tooltip variant renders no message box; describe the input by the
+  // tooltip's content instead so the status is still announced.
+  statusTooltipDescribedBy, showsDisabledMessage ? disabledMessageTooltip.describedBy : null], inputGroup);
+
+  // Pending input while user is typing (null = show formatted value)
+  const [pendingInput, setPendingInput] = useState(null);
+  const [isFocused, setIsFocused] = useState(false);
+
+  // Format function based on hourFormat
+  const formatDisplayTime = hourFormat === '12h' ? formatDisplayTime12h : formatDisplayTime24h;
+
+  // Unified change handler that fires both onChange and changeAction
+  const fireChange = useCallback(newValue => {
+    onChange?.(newValue);
+    if (changeAction) {
+      startTransition(async () => {
+        setOptimisticValue(newValue);
+        await changeAction(newValue);
+      });
+    }
+  }, [onChange, changeAction, startTransition, setOptimisticValue]);
+
+  // Display value: pending input if typing, otherwise formatted value
+  const displayValue = useMemo(() => {
+    if (pendingInput !== null) {
+      return pendingInput;
+    }
+    return optimisticValue ? formatDisplayTime(optimisticValue, hasSeconds) : '';
+  }, [pendingInput, optimisticValue, formatDisplayTime, hasSeconds]);
+
+  // Check if current input is valid (for styling purposes)
+  const isInputValid = useMemo(() => {
+    // Only check pending input for validity styling
+    if (pendingInput === null || !pendingInput.trim()) {
+      return true;
+    }
+    const parsed = parseTimeInput(pendingInput, hasSeconds);
+    if (!parsed) {
+      return false;
+    }
+    // Also check min/max range
+    return isTimeInRange(parsed, min, max);
+  }, [pendingInput, hasSeconds, min, max]);
+
+  // Placeholder that shows format hint when focused and empty
+  const displayPlaceholder = useMemo(() => {
+    if (isFocused && !displayValue) {
+      return hourFormat === '12h' ? 'e.g., 2:30 PM' : 'e.g., 14:30';
+    }
+    return placeholder;
+  }, [isFocused, displayValue, hourFormat, placeholder]);
+
+  // Handle input text change - update immediately if valid
+  const handleInputChange = useCallback(e => {
+    // With a disabledMessage the input drops `disabled` for focusability, so
+    // guard value mutation explicitly (readOnly also blocks typing).
+    if (isDisabled) {
+      return;
+    }
+    const newValue = e.target.value;
+    setPendingInput(newValue);
+
+    // If the input is valid, update immediately (don't wait for blur)
+    const parsed = parseTimeInput(newValue, hasSeconds);
+    if (parsed && isTimeInRange(parsed, min, max) && parsed !== value) {
+      fireChange(parsed);
+    }
+  }, [hasSeconds, min, max, value, fireChange, isDisabled]);
+
+  // Handle focus
+  const handleFocus = useCallback(() => {
+    // A disabled input stays focusable (via aria-disabled) so its reason is
+    // discoverable, but it must not present editing affordances — keep the
+    // static placeholder rather than swapping in the format hint.
+    if (isDisabled) {
+      return;
+    }
+    setIsFocused(true);
+  }, [isDisabled]);
+
+  // Handle blur - validate and clear pending input
+  const handleBlur = useCallback(_e => {
+    setIsFocused(false);
+    if (pendingInput === null) {
+      return;
+    }
+    if (!pendingInput.trim()) {
+      // Empty input clears the value
+      if (value !== undefined) {
+        fireChange(undefined);
+      }
+      setPendingInput(null);
+      return;
+    }
+    const parsed = parseTimeInput(pendingInput, hasSeconds);
+    if (parsed && isTimeInRange(parsed, min, max)) {
+      // Valid time - update if different
+      if (parsed !== value) {
+        fireChange(parsed);
+      }
+    }
+    // Clear pending input - display will revert to formatted value
+    setPendingInput(null);
+  }, [pendingInput, value, fireChange, hasSeconds, min, max]);
+
+  // Handle keyboard navigation on input
+  const handleInputKeyDown = useCallback(e => {
+    // Arrow-key adjustment mutates the value; block it while showing a
+    // disabled reason (the input keeps focusability via aria-disabled).
+    if (isDisabled) {
+      return;
+    }
+    if (e.key === 'ArrowUp' || e.key === 'ArrowDown') {
+      e.preventDefault();
+
+      // Get current time or default to now
+      let currentTime = value;
+      if (!currentTime) {
+        const now = new Date();
+        currentTime = formatISOTime({
+          hour: now.getHours(),
+          minute: now.getMinutes(),
+          second: now.getSeconds()
+        }, hasSeconds);
+      }
+      const delta = e.key === 'ArrowUp' ? increment : -increment;
+      const newTime = adjustTime(currentTime, delta, hasSeconds);
+
+      // Check if within range
+      if (isTimeInRange(newTime, min, max)) {
+        fireChange(newTime);
+      }
+    }
+  }, [value, hasSeconds, increment, min, max, fireChange, isDisabled]);
+
+  // Handle clear button click
+  const handleClear = useCallback(() => {
+    fireChange(undefined);
+    inputRef.current?.focus();
+  }, [fireChange]);
+
+  // Focus input when clicking anywhere on the wrapper (icons, padding, etc.)
+  const {
+    onClick: handleWrapperClick,
+    onMouseUp: handleWrapperMouseUp
+  } = useInputContainer({
+    containerRef,
+    inputRef,
+    disabled: isDisabled
+  });
+  const inputWrapper = /*#__PURE__*/_jsxs("div", {
+    ref: el => {
+      containerRef.current = el;
+      // Anchor + hover/focus listeners for the disabled-message tooltip.
+      // Handlers are gated internally by isEnabled, so attaching
+      // unconditionally is safe.
+      disabledMessageTooltip.ref(el);
+    },
+    onClick: handleWrapperClick,
+    onMouseUp: handleWrapperMouseUp,
+    ...mergeProps(themeProps('time-input', {
+      size,
+      status: status?.type ?? null
+    }), stylex.props(inputWrapperStyles.base, sizeStyles[size], isDisabled && inputWrapperStyles.disabled, status && inputStatusBorderStyles[status.type], status && !isDisabled && inputStatusHoverShadowStyles[status.type], status && inputStatusFocusWithinStyles[status.type], inputGroup && groupStyles.inGroup, xstyle), className, style),
+    children: [/*#__PURE__*/_jsx("div", {
+      ...{
+        className: "x78zum5 x6s0dn4 xl56j7k x2lah0s"
+      },
+      children: /*#__PURE__*/_jsx(Icon, {
+        icon: "clock",
+        size: "sm",
+        color: "secondary"
+      })
+    }), inputGroup && /*#__PURE__*/_jsx(VisuallyHidden, {
+      id: inputLabelID,
+      children: label
+    }), inputGroup && description && /*#__PURE__*/_jsx(VisuallyHidden, {
+      as: "div",
+      id: descriptionID,
+      children: description
+    }), inputGroup && status?.message && /*#__PURE__*/_jsx(VisuallyHidden, {
+      as: "div",
+      id: statusMessageID,
+      children: status.message
+    }), /*#__PURE__*/_jsx("input", {
+      ref: mergeRefs(ref, inputRef),
+      id: id,
+      type: "text",
+      value: displayValue,
+      onChange: handleInputChange,
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      onKeyDown: handleInputKeyDown,
+      placeholder: displayPlaceholder
+      // With a disabledMessage the input keeps focusability via
+      // aria-disabled so the reason is focus-discoverable; typing and
+      // arrow-key adjustment are blocked with readOnly and the guards.
+      ,
+      disabled: isDisabled && !showsDisabledMessage,
+      "aria-disabled": showsDisabledMessage ? 'true' : undefined,
+      readOnly: showsDisabledMessage || undefined,
+      autoFocus: hasAutoFocus,
+      "data-autofocus": hasAutoFocus || undefined,
+      "aria-describedby": ariaDescribedBy,
+      "aria-required": isRequired === true ? 'true' : undefined,
+      "aria-invalid": status?.type === 'error' || !isInputValid ? 'true' : undefined,
+      "aria-busy": isBusy || undefined,
+      "aria-labelledby": ariaLabelledBy,
+      ...{
+        0: {
+          className: "x1lliihq x98rzlu xeuugli xc342km xng3xce x1717udv x9ynric xjm74w1 x6pjikd xw6l6zx x1tgivj0 xjbqb8w x1a2a7pz xeyghm5"
+        },
+        2: {
+          className: "x1lliihq x98rzlu xeuugli xc342km xng3xce x1717udv x9ynric xjm74w1 x6pjikd xw6l6zx x1tgivj0 xjbqb8w x1a2a7pz xeyghm5 x1h6gzvc"
+        },
+        1: {
+          className: "x1lliihq x98rzlu xeuugli xc342km xng3xce x1717udv x9ynric xjm74w1 x6pjikd xw6l6zx xjbqb8w x1a2a7pz xeyghm5 xv1l7n4"
+        },
+        3: {
+          className: "x1lliihq x98rzlu xeuugli xc342km xng3xce x1717udv x9ynric xjm74w1 x6pjikd xw6l6zx xjbqb8w x1a2a7pz xeyghm5 x1h6gzvc xv1l7n4"
+        }
+      }[!!isDisabled << 1 | !!!isInputValid << 0]
+    }), /*#__PURE__*/_jsx(VisuallyHidden, {
+      as: "div",
+      role: "alert",
+      "aria-live": "assertive",
+      children: !isInputValid ? 'Invalid time' : ''
+    }), isBusy && /*#__PURE__*/_jsx(Spinner, {
+      size: "sm"
+    }), hasClear && value && !isDisabled && /*#__PURE__*/_jsx("button", {
+      type: "button",
+      onClick: handleClear,
+      "aria-label": t('@pharos.timeInput.clearLabel', {
+        label
+      }),
+      ...{
+        className: "x78zum5 x6s0dn4 xl56j7k x1717udv x1ghz6dp xc342km xng3xce xjbqb8w x1ypdohk xh6dtrn x1a2a7pz x1p25gnr x1y3gkto"
+      },
+      children: /*#__PURE__*/_jsx(Icon, {
+        icon: "close",
+        size: "sm",
+        color: "secondary"
+      })
+    }), statusIcon]
+  });
+  if (inputGroup) {
+    return /*#__PURE__*/_jsxs(_Fragment, {
+      children: [inputWrapper, showsDisabledMessage && disabledMessageTooltip.renderTooltip(disabledMessage)]
+    });
+  }
+  return /*#__PURE__*/_jsxs(Field, {
+    label: label,
+    isLabelHidden: isLabelHidden,
+    description: description,
+    inputID: id,
+    descriptionID: description ? descriptionID : undefined,
+    isOptional: isOptional,
+    isRequired: isRequired,
+    isDisabled: isDisabled,
+    status: status ? {
+      type: status.type,
+      message: status.message,
+      messageID: status.message ? statusMessageID : undefined
+    } : undefined,
+    statusVariant: statusVariant,
+    labelTooltip: labelTooltip,
+    width: width,
+    children: [inputWrapper, showsDisabledMessage && disabledMessageTooltip.renderTooltip(disabledMessage)]
+  });
+}
+TimeInput.displayName = 'TimeInput';

package/dist/TimeInput/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @file index.ts
+ * @input Imports TimeInput components and types
+ * @output Exports TimeInput and related types
+ * @position Component entry point; re-exported by /packages/core/src/index.ts
+ *
+ * SYNC: When modified, update this header and /packages/core/src/TimeInput/TimeInput.doc.mjs
+ */
+export { TimeInput } from './TimeInput';
+export type { TimeInputProps, TimeInputSize, TimeInputHourFormat, TimeInputStatus, TimeInputStatusType, } from './TimeInput';
+export type { ISOTimeString } from '../utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/TimeInput/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/TimeInput/index.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AAEH,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AACtC,YAAY,EACV,cAAc,EACd,aAAa,EACb,mBAAmB,EACnB,eAAe,EACf,mBAAmB,GACpB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAC,aAAa,EAAC,MAAM,UAAU,CAAC"}

package/dist/TimeInput/index.js

@@ -0,0 +1,13 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+'use client';
+
+/**
+ * @file index.ts
+ * @input Imports TimeInput components and types
+ * @output Exports TimeInput and related types
+ * @position Component entry point; re-exported by /packages/core/src/index.ts
+ *
+ * SYNC: When modified, update this header and /packages/core/src/TimeInput/TimeInput.doc.mjs
+ */
+export { TimeInput } from "./TimeInput.js";

package/dist/Timestamp/Timestamp.d.ts

@@ -0,0 +1,114 @@
+import type { TextType, TextSize, TextColor, TextWeight } from '../theme/types';
+import type { BaseProps } from '../BaseProps';
+import type { TimestampTooltipEntry } from './tooltipEntries';
+export type TimestampFormat = 'relative' | 'auto' | 'date' | 'date_long' | 'date_weekday' | 'date_time' | 'time' | 'system_date' | 'system_date_time' | 'system_time';
+export interface TimestampProps extends BaseProps<HTMLTimeElement> {
+    /** Ref forwarded to the root `<time>` element. */
+    ref?: React.Ref<HTMLTimeElement>;
+    /** The date/time to display. Accepts Unix timestamps (seconds) or ISO 8601 strings. */
+    value: string | number;
+    /**
+     * Display format.
+     * - `'relative'`: "2 hours ago", "yesterday", "now"
+     * - `'auto'`: Relative for recent times, `date_time` for older
+     * - `'date'`: "Mar 21, 2025"
+     * - `'date_long'`: "March 21, 2025"
+     * - `'date_weekday'`: "Wed, Mar 21, 2025"
+     * - `'date_time'`: "Mar 21, 2025, 2:51 PM"
+     * - `'time'`: "2:51 PM"
+     * - `'system_date'`: "2025-03-21"
+     * - `'system_date_time'`: "2025-03-21 14:51:53"
+     * - `'system_time'`: "14:51:53"
+     * @default 'auto'
+     */
+    format?: TimestampFormat;
+    /**
+     * Threshold in seconds for 'auto' format to switch from relative to date_time.
+     * @default 604800 (7 days)
+     */
+    autoThreshold?: number;
+    /**
+     * Whether to show a tooltip with the full date/time on hover.
+     * @default true
+     */
+    hasTooltip?: boolean;
+    /**
+     * Lines to show in the hover tooltip, so one instant can be read in several
+     * time zones and/or formats at once. Each entry is one line, rendered in the
+     * order given, with an optional label.
+     *
+     * Configuring entries also attaches the tooltip to absolute formats, which
+     * otherwise have no tooltip at all. `hasTooltip={false}` still suppresses it,
+     * and an empty array is treated as no configuration.
+     *
+     * @default undefined — a single line with the full absolute time in the
+     *   viewer's own time zone
+     * @example
+     * ```
+     * <Timestamp
+     *   value={savedAt}
+     *   tooltipEntries={[
+     *     {label: 'Your time'},
+     *     {timezoneID: 'UTC', label: 'UTC'},
+     *   ]}
+     * />
+     * ```
+     */
+    tooltipEntries?: ReadonlyArray<TimestampTooltipEntry>;
+    /**
+     * Whether to append the timezone abbreviation after the timestamp text.
+     * Applies to the date_time and time formats. The system_* formats stay
+     * machine-readable and never carry a timezone abbreviation.
+     *
+     * Affects the visible text only — use `tooltipEntries` to control the
+     * tooltip's time zones.
+     * @default false
+     */
+    isTimezoneShown?: boolean;
+    /**
+     * Whether the relative time should update live.
+     * @default false
+     */
+    isLive?: boolean;
+    /**
+     * Semantic text type. Determines size, weight, and line-height from theme.
+     * @default 'supporting'
+     */
+    type?: TextType;
+    /**
+     * Explicit font size override. Overrides the size from `type`.
+     */
+    size?: TextSize;
+    /**
+     * Text color.
+     * @default 'secondary'
+     */
+    color?: TextColor;
+    /**
+     * Font weight override.
+     */
+    weight?: TextWeight;
+    /** Test ID for testing frameworks. */
+    'data-testid'?: string;
+}
+/**
+ * Displays a formatted timestamp as human-readable text.
+ *
+ * Renders a semantic `<time>` element with an ISO 8601 `datetime` attribute,
+ * styled via Text. Supports relative ("2 hours ago"), multiple absolute
+ * formats, and auto formatting. Optionally shows a tooltip with the full
+ * absolute time and can update live.
+ *
+ * @example
+ * ```
+ * <Timestamp value="2026-02-19T17:00:00Z" />
+ * <Timestamp value={1740000000} format="date" />
+ * <Timestamp value={date} format="auto" isLive />
+ * <Timestamp value={event.timestamp} format="system_date_time" />
+ * ```
+ */
+export declare function Timestamp({ value, format, autoThreshold, hasTooltip, tooltipEntries, isTimezoneShown, isLive, type, size, color, weight, xstyle, className, style, ref, 'data-testid': testId, }: TimestampProps): import("react").JSX.Element | null;
+export declare namespace Timestamp {
+    var displayName: string;
+}
+//# sourceMappingURL=Timestamp.d.ts.map

package/dist/Timestamp/Timestamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Timestamp.d.ts","sourceRoot":"","sources":["../../src/Timestamp/Timestamp.tsx"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAC,MAAM,gBAAgB,CAAC;AAG9E,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AAK5C,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,kBAAkB,CAAC;AAU5D,MAAM,MAAM,eAAe,GACvB,UAAU,GACV,MAAM,GACN,MAAM,GACN,WAAW,GACX,cAAc,GACd,WAAW,GACX,MAAM,GACN,aAAa,GACb,kBAAkB,GAClB,aAAa,CAAC;AAElB,MAAM,WAAW,cAAe,SAAQ,SAAS,CAAC,eAAe,CAAC;IAChE,kDAAkD;IAClD,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;IACjC,uFAAuF;IACvF,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,cAAc,CAAC,EAAE,aAAa,CAAC,qBAAqB,CAAC,CAAC;IACtD;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB;;OAEG;IACH,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB;;;OAGG;IACH,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB;;OAEG;IACH,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,sCAAsC;IACtC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AA2LD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,EACxB,KAAK,EACL,MAAe,EACf,aAAsC,EACtC,UAAiB,EACjB,cAAc,EACd,eAAuB,EACvB,MAAc,EACd,IAAmB,EACnB,IAAI,EACJ,KAAmB,EACnB,MAAM,EACN,MAAM,EACN,SAAS,EACT,KAAK,EACL,GAAG,EACH,aAAa,EAAE,MAAM,GACtB,EAAE,cAAc,sCA4IhB;yBA7Je,SAAS"}