@seedgrid/fe-components 0.2.8 → 0.2.10

package/dist/inputs/SgInputOTP.js

@@ -0,0 +1,499 @@
+"use client";
+import { createElement as _createElement } from "react";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from "react";
+import { Controller } from "react-hook-form";
+import { t, useComponentsI18n } from "../i18n";
+const DEFAULT_MASK = "999999";
+const DIGIT_RE = /^[0-9]$/;
+const ALPHANUMERIC_RE = /^[A-Za-z0-9]$/;
+function normalizeExternalValue(value) {
+    if (value == null)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number")
+        return String(value);
+    return String(value);
+}
+function toCssSize(value) {
+    if (value === undefined)
+        return "fit-content";
+    return typeof value === "number" ? `${value}px` : value;
+}
+function mergeRefs(...refs) {
+    return (node) => {
+        for (const ref of refs) {
+            if (!ref)
+                continue;
+            if (typeof ref === "function") {
+                ref(node);
+                continue;
+            }
+            if (typeof ref === "object" && "current" in ref) {
+                ref.current = node;
+            }
+        }
+    };
+}
+function buildMask(source) {
+    const tokens = [];
+    const slots = [];
+    let nextSlotIndex = 0;
+    for (const char of source) {
+        if (char === "#" || char === "9") {
+            const slot = {
+                type: "slot",
+                slotIndex: nextSlotIndex,
+                slotKind: char === "#" ? "alphanumeric" : "digit"
+            };
+            tokens.push(slot);
+            slots.push(slot);
+            nextSlotIndex += 1;
+        }
+        else {
+            tokens.push({ type: "separator", value: char });
+        }
+    }
+    return { tokens, slots };
+}
+function parseMask(mask) {
+    const source = mask && mask.length > 0 ? mask : DEFAULT_MASK;
+    const parsed = buildMask(source);
+    if (parsed.slots.length > 0)
+        return parsed;
+    return buildMask(DEFAULT_MASK);
+}
+function buildEmptySlotValues(slots) {
+    return Array.from({ length: slots.length }, () => "");
+}
+function isAcceptedChar(slot, char) {
+    if (char.length !== 1)
+        return false;
+    if (slot.slotKind === "digit")
+        return DIGIT_RE.test(char);
+    return ALPHANUMERIC_RE.test(char);
+}
+function textToSlotValues(text, slots) {
+    const next = buildEmptySlotValues(slots);
+    let nextSlotIndex = 0;
+    for (const char of text) {
+        if (nextSlotIndex >= slots.length)
+            break;
+        const slot = slots[nextSlotIndex];
+        if (!slot)
+            break;
+        if (!isAcceptedChar(slot, char))
+            continue;
+        next[nextSlotIndex] = char;
+        nextSlotIndex += 1;
+    }
+    return next;
+}
+function slotValuesToRaw(slotValues) {
+    return slotValues.join("");
+}
+function hasRemainingSlotBeforeLastFilled(tokens, tokenIndex, lastFilledSlotIndex) {
+    for (let index = tokenIndex + 1; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (!token || token.type !== "slot")
+            continue;
+        return token.slotIndex <= lastFilledSlotIndex;
+    }
+    return false;
+}
+function slotValuesToMasked(tokens, slotValues) {
+    let lastFilledSlotIndex = -1;
+    for (let index = slotValues.length - 1; index >= 0; index -= 1) {
+        const value = slotValues[index];
+        if (!value)
+            continue;
+        lastFilledSlotIndex = index;
+        break;
+    }
+    if (lastFilledSlotIndex < 0)
+        return "";
+    let masked = "";
+    let hasWrittenAnySlot = false;
+    for (let tokenIndex = 0; tokenIndex < tokens.length; tokenIndex += 1) {
+        const token = tokens[tokenIndex];
+        if (!token)
+            continue;
+        if (token.type === "separator") {
+            if (!hasWrittenAnySlot)
+                continue;
+            if (!hasRemainingSlotBeforeLastFilled(tokens, tokenIndex, lastFilledSlotIndex))
+                continue;
+            masked += token.value;
+            continue;
+        }
+        if (token.slotIndex > lastFilledSlotIndex)
+            break;
+        const value = slotValues[token.slotIndex] ?? "";
+        if (!value)
+            continue;
+        masked += value;
+        hasWrittenAnySlot = true;
+    }
+    return masked;
+}
+function areSlotValuesEqual(left, right) {
+    if (left.length !== right.length)
+        return false;
+    for (let index = 0; index < left.length; index += 1) {
+        if ((left[index] ?? "") !== (right[index] ?? ""))
+            return false;
+    }
+    return true;
+}
+function clampIndex(index, slotCount) {
+    if (slotCount <= 0)
+        return 0;
+    if (index < 0)
+        return 0;
+    if (index > slotCount - 1)
+        return slotCount - 1;
+    return index;
+}
+const SgInputOTPBase = React.forwardRef(function SgInputOTPBase(props, ref) {
+    const i18n = useComponentsI18n();
+    const { id, label, hintText, mask, value, defaultValue, error, className, groupClassName, slotClassName, separatorClassName, inputProps, width, enabled = true, readOnly = false, required = false, requiredMessage, validation, validateOnBlur = true, onValidation, onChange, onRawChange, onComplete, onEnter, onExit, onClear, name, onFieldChange, onFieldBlur, hiddenFieldRef } = props;
+    const parsedMask = React.useMemo(() => parseMask(mask), [mask]);
+    const tokens = parsedMask.tokens;
+    const slots = parsedMask.slots;
+    const slotCount = slots.length;
+    const makeSlotValues = React.useCallback((text) => textToSlotValues(text, slots), [slots]);
+    const [slotValues, setSlotValues] = React.useState(() => {
+        const seeded = normalizeExternalValue(value ?? defaultValue ?? "");
+        return makeSlotValues(seeded);
+    });
+    const slotValuesRef = React.useRef(slotValues);
+    const slotRefs = React.useRef([]);
+    const hiddenInputRef = React.useRef(null);
+    const hasInteractedRef = React.useRef(false);
+    const focusWithinRef = React.useRef(false);
+    const [internalError, setInternalError] = React.useState(null);
+    const { ref: inputRef, className: inputClassName, onChange: onSlotInputChange, onPaste: onSlotInputPaste, onKeyDown: onSlotInputKeyDown, onFocus: onSlotInputFocus, onBlur: onSlotInputBlur, autoComplete: slotAutoComplete, inputMode: slotInputMode, pattern: slotPattern, disabled: inputDisabled, readOnly: inputReadOnly, autoFocus: slotAutoFocus, ...restSlotInputProps } = inputProps ?? {};
+    React.useEffect(() => {
+        slotValuesRef.current = slotValues;
+    }, [slotValues]);
+    React.useEffect(() => {
+        if (slotRefs.current.length <= slotCount)
+            return;
+        slotRefs.current = slotRefs.current.slice(0, slotCount);
+    }, [slotCount]);
+    React.useEffect(() => {
+        if (value === undefined)
+            return;
+        const next = makeSlotValues(normalizeExternalValue(value));
+        setSlotValues((prev) => (areSlotValuesEqual(prev, next) ? prev : next));
+    }, [makeSlotValues, value]);
+    React.useEffect(() => {
+        if (value !== undefined)
+            return;
+        setSlotValues((prev) => {
+            const next = makeSlotValues(slotValuesToRaw(prev));
+            return areSlotValuesEqual(prev, next) ? prev : next;
+        });
+    }, [makeSlotValues, value]);
+    const focusSlot = React.useCallback((requestedIndex) => {
+        const nextIndex = clampIndex(requestedIndex, slotCount);
+        const node = slotRefs.current[nextIndex];
+        if (!node)
+            return;
+        node.focus();
+        node.select();
+    }, [slotCount]);
+    const runValidation = React.useCallback((rawValue, maskedValue) => {
+        if (!rawValue && required) {
+            const message = requiredMessage ?? t(i18n, "components.inputs.required");
+            setInternalError(message);
+            onValidation?.(message);
+            return message;
+        }
+        if (validation) {
+            const message = validation(rawValue, maskedValue);
+            setInternalError(message);
+            onValidation?.(message ?? null);
+            return message ?? null;
+        }
+        setInternalError(null);
+        onValidation?.(null);
+        return null;
+    }, [i18n, onValidation, required, requiredMessage, validation]);
+    const commitSlotValues = React.useCallback((nextSlotValues, options) => {
+        const previousRawValue = slotValuesToRaw(slotValuesRef.current);
+        const nextRawValue = slotValuesToRaw(nextSlotValues);
+        const nextMaskedValue = slotValuesToMasked(tokens, nextSlotValues);
+        hasInteractedRef.current = true;
+        slotValuesRef.current = nextSlotValues;
+        setSlotValues(nextSlotValues);
+        if (hiddenInputRef.current) {
+            hiddenInputRef.current.value = nextRawValue;
+        }
+        onChange?.(nextMaskedValue);
+        onRawChange?.(nextRawValue);
+        onFieldChange?.(nextRawValue);
+        const shouldValidateNow = options?.triggerValidation ?? !validateOnBlur;
+        if (shouldValidateNow) {
+            runValidation(nextRawValue, nextMaskedValue);
+        }
+        const isComplete = nextSlotValues.length > 0 && nextSlotValues.every((part) => part.length === 1);
+        if (isComplete) {
+            onComplete?.(nextMaskedValue);
+        }
+        if (previousRawValue.length > 0 && nextRawValue.length === 0) {
+            onClear?.();
+        }
+        if (options?.focusIndex === undefined)
+            return;
+        const nextFocusIndex = clampIndex(options.focusIndex, slotCount);
+        if (typeof window !== "undefined") {
+            window.requestAnimationFrame(() => focusSlot(nextFocusIndex));
+            return;
+        }
+        focusSlot(nextFocusIndex);
+    }, [
+        focusSlot,
+        onChange,
+        onClear,
+        onComplete,
+        onFieldChange,
+        onRawChange,
+        runValidation,
+        slotCount,
+        tokens,
+        validateOnBlur
+    ]);
+    const applyTextFrom = React.useCallback((startSlotIndex, text, replaceTail) => {
+        if (!text)
+            return;
+        const next = [...slotValuesRef.current];
+        const boundedStart = clampIndex(startSlotIndex, slotCount);
+        if (replaceTail) {
+            for (let index = boundedStart; index < next.length; index += 1) {
+                next[index] = "";
+            }
+        }
+        let pointer = boundedStart;
+        for (const char of text) {
+            if (pointer >= slots.length)
+                break;
+            const slot = slots[pointer];
+            if (!slot)
+                break;
+            if (!isAcceptedChar(slot, char))
+                continue;
+            next[pointer] = char;
+            pointer += 1;
+        }
+        const focusIndex = clampIndex(pointer, slotCount);
+        commitSlotValues(next, { focusIndex });
+    }, [commitSlotValues, slotCount, slots]);
+    React.useImperativeHandle(ref, () => ({
+        focus: (slotIndex = 0) => {
+            focusSlot(slotIndex);
+        },
+        clear: () => {
+            commitSlotValues(buildEmptySlotValues(slots), {
+                focusIndex: 0,
+                triggerValidation: !validateOnBlur
+            });
+        },
+        getRawValue: () => slotValuesToRaw(slotValuesRef.current),
+        getMaskedValue: () => slotValuesToMasked(tokens, slotValuesRef.current)
+    }), [commitSlotValues, focusSlot, slots, tokens, validateOnBlur]);
+    const handleGroupFocusCapture = React.useCallback(() => {
+        if (focusWithinRef.current)
+            return;
+        focusWithinRef.current = true;
+        onEnter?.();
+    }, [onEnter]);
+    const handleGroupBlurCapture = React.useCallback((event) => {
+        const nextTarget = event.relatedTarget;
+        if (nextTarget && event.currentTarget.contains(nextTarget))
+            return;
+        focusWithinRef.current = false;
+        const nextRawValue = slotValuesToRaw(slotValuesRef.current);
+        const nextMaskedValue = slotValuesToMasked(tokens, slotValuesRef.current);
+        if (validateOnBlur || hasInteractedRef.current) {
+            runValidation(nextRawValue, nextMaskedValue);
+        }
+        onExit?.();
+        onFieldBlur?.(nextRawValue);
+    }, [onExit, onFieldBlur, runValidation, tokens, validateOnBlur]);
+    const handleSlotChange = React.useCallback((slotIndex, event) => {
+        onSlotInputChange?.(event);
+        if (event.defaultPrevented)
+            return;
+        const slot = slots[slotIndex];
+        if (!slot)
+            return;
+        const typed = event.currentTarget.value ?? "";
+        if (!typed) {
+            const next = [...slotValuesRef.current];
+            next[slotIndex] = "";
+            commitSlotValues(next, { focusIndex: slotIndex });
+            return;
+        }
+        if (typed.length > 1) {
+            applyTextFrom(slotIndex, typed, true);
+            return;
+        }
+        const nextChar = typed.slice(-1);
+        if (!isAcceptedChar(slot, nextChar)) {
+            event.currentTarget.value = slotValuesRef.current[slotIndex] ?? "";
+            return;
+        }
+        const next = [...slotValuesRef.current];
+        next[slotIndex] = nextChar;
+        commitSlotValues(next, { focusIndex: slotIndex + 1 });
+    }, [applyTextFrom, commitSlotValues, onSlotInputChange, slots]);
+    const handleSlotPaste = React.useCallback((slotIndex, event) => {
+        onSlotInputPaste?.(event);
+        if (event.defaultPrevented)
+            return;
+        event.preventDefault();
+        const pasted = event.clipboardData.getData("text") ?? "";
+        if (!pasted)
+            return;
+        applyTextFrom(slotIndex, pasted, true);
+    }, [applyTextFrom, onSlotInputPaste]);
+    const handleSlotKeyDown = React.useCallback((slotIndex, event) => {
+        onSlotInputKeyDown?.(event);
+        if (event.defaultPrevented)
+            return;
+        const slot = slots[slotIndex];
+        if (!slot)
+            return;
+        if (event.key === "ArrowLeft") {
+            event.preventDefault();
+            focusSlot(slotIndex - 1);
+            return;
+        }
+        if (event.key === "ArrowRight") {
+            event.preventDefault();
+            focusSlot(slotIndex + 1);
+            return;
+        }
+        if (event.key === "Backspace") {
+            event.preventDefault();
+            const next = [...slotValuesRef.current];
+            const currentValue = next[slotIndex] ?? "";
+            if (currentValue) {
+                next[slotIndex] = "";
+                commitSlotValues(next, { focusIndex: slotIndex });
+                return;
+            }
+            if (slotIndex === 0)
+                return;
+            next[slotIndex - 1] = "";
+            commitSlotValues(next, { focusIndex: slotIndex - 1 });
+            return;
+        }
+        if (event.key === "Delete") {
+            event.preventDefault();
+            const next = [...slotValuesRef.current];
+            next[slotIndex] = "";
+            commitSlotValues(next, { focusIndex: slotIndex });
+            return;
+        }
+        if (event.key.length === 1 && !event.ctrlKey && !event.metaKey && !event.altKey) {
+            if (!isAcceptedChar(slot, event.key)) {
+                event.preventDefault();
+            }
+        }
+    }, [commitSlotValues, focusSlot, onSlotInputKeyDown, slots]);
+    const hasError = Boolean(error ?? internalError);
+    const resolvedError = error ?? internalError ?? undefined;
+    const isDisabled = enabled === false || Boolean(inputDisabled);
+    const isReadOnly = readOnly || Boolean(inputReadOnly);
+    const mergedSlotClass = [
+        "h-12 w-11 border bg-white px-0 text-center text-base font-medium shadow-sm outline-none transition-all",
+        hasError
+            ? "border-[hsl(var(--destructive))] focus:border-[hsl(var(--destructive))] focus:ring-2 focus:ring-[hsl(var(--destructive)/0.25)]"
+            : "border-border focus:border-[hsl(var(--primary))] focus:ring-2 focus:ring-[hsl(var(--primary)/0.25)]",
+        "disabled:cursor-not-allowed disabled:bg-muted/40 disabled:text-foreground/40",
+        "read-only:cursor-default read-only:bg-muted/30",
+        inputClassName ?? "",
+        slotClassName ?? ""
+    ]
+        .filter(Boolean)
+        .join(" ");
+    const setHiddenInputRef = React.useMemo(() => mergeRefs(hiddenFieldRef, hiddenInputRef), [hiddenFieldRef]);
+    const setSlotRef = React.useCallback((slotIndex, node) => {
+        slotRefs.current[slotIndex] = node;
+        if (slotIndex !== 0)
+            return;
+        if (!inputRef)
+            return;
+        if (typeof inputRef === "function") {
+            inputRef(node);
+            return;
+        }
+        if (typeof inputRef === "object" && "current" in inputRef) {
+            inputRef.current = node;
+        }
+    }, [inputRef]);
+    const labelText = label ?? "";
+    const firstSlotId = `${id}-slot-0`;
+    return (_jsxs("div", { className: className, style: { width: toCssSize(width) }, children: [labelText ? (_jsxs("label", { htmlFor: firstSlotId, className: "mb-2 block text-sm font-medium text-foreground/80", children: [labelText, required ? (_jsx("span", { className: "ml-1 text-[hsl(var(--destructive))]", "aria-hidden": "true", children: "*" })) : null] })) : null, _jsx("div", { className: groupClassName ?? "inline-flex items-center gap-2", onFocusCapture: handleGroupFocusCapture, onBlurCapture: handleGroupBlurCapture, role: "group", "aria-label": labelText || id, "aria-invalid": hasError || undefined, children: tokens.map((token, tokenIndex) => {
+                    if (token.type === "separator") {
+                        return (_jsx("span", { className: separatorClassName ??
+                                "select-none px-1 text-lg font-semibold leading-none text-foreground/60", "aria-hidden": "true", children: token.value }, `${id}-separator-${tokenIndex}`));
+                    }
+                    const slotIndex = token.slotIndex;
+                    const slotValue = slotValues[slotIndex] ?? "";
+                    const computedInputMode = token.slotKind === "digit" ? "numeric" : slotInputMode ?? "text";
+                    const computedPattern = token.slotKind === "digit"
+                        ? "[0-9]*"
+                        : slotPattern ?? "[A-Za-z0-9]*";
+                    const slotShapeClass = slotCount === 1
+                        ? "rounded-2xl"
+                        : slotIndex === 0
+                            ? "rounded-l-2xl rounded-r-md"
+                            : slotIndex === slotCount - 1
+                                ? "rounded-r-2xl rounded-l-md"
+                                : "rounded-md";
+                    return (_createElement("input", { ...restSlotInputProps, key: `${id}-slot-${slotIndex}`, id: `${id}-slot-${slotIndex}`, type: "text", value: slotValue, maxLength: 1, autoComplete: slotIndex === 0 ? slotAutoComplete ?? "one-time-code" : "off", autoFocus: slotIndex === 0 ? slotAutoFocus : false, inputMode: computedInputMode, pattern: computedPattern, className: `${mergedSlotClass} ${slotShapeClass}`, disabled: isDisabled, readOnly: isReadOnly, "aria-label": labelText ? `${labelText} ${slotIndex + 1}` : `OTP ${slotIndex + 1}`, ref: (node) => setSlotRef(slotIndex, node), onFocus: (event) => {
+                            event.currentTarget.select();
+                            onSlotInputFocus?.(event);
+                        }, onBlur: (event) => {
+                            onSlotInputBlur?.(event);
+                        }, onChange: (event) => handleSlotChange(slotIndex, event), onPaste: (event) => handleSlotPaste(slotIndex, event), onKeyDown: (event) => handleSlotKeyDown(slotIndex, event) }));
+                }) }), hintText ? _jsx("p", { className: "mt-2 text-sm text-muted-foreground", children: hintText }) : null, resolvedError ? _jsx("p", { "data-sg-error": true, className: "mt-1 text-xs text-red-600", children: resolvedError }) : null, _jsx("input", { id: `${id}-value`, type: "hidden", name: name, value: slotValuesToRaw(slotValues), ref: setHiddenInputRef, readOnly: true, "aria-hidden": "true" })] }));
+});
+function createSyntheticChangeEvent(name, value) {
+    const target = { name, value };
+    return {
+        target,
+        currentTarget: target
+    };
+}
+function createSyntheticBlurEvent(name, value) {
+    const target = { name, value };
+    return {
+        target,
+        currentTarget: target,
+        relatedTarget: null
+    };
+}
+export const SgInputOTP = React.forwardRef(function SgInputOTP(props, ref) {
+    const { control, name, register, rules, ...rest } = props;
+    if (name && register) {
+        const registration = register(name, rules);
+        return (_jsx(SgInputOTPBase, { ...rest, ref: ref, name: name, hiddenFieldRef: registration.ref, onFieldChange: (rawValue) => {
+                registration.onChange(createSyntheticChangeEvent(name, rawValue));
+            }, onFieldBlur: (rawValue) => {
+                registration.onBlur(createSyntheticBlurEvent(name, rawValue));
+            } }));
+    }
+    if (control && name) {
+        return (_jsx(Controller, { name: name, control: control, render: ({ field, fieldState }) => (_jsx(SgInputOTPBase, { ...rest, ref: ref, name: name, value: normalizeExternalValue(field.value), error: rest.error ?? fieldState.error?.message, hiddenFieldRef: field.ref, onFieldChange: (rawValue) => {
+                    field.onChange(rawValue);
+                }, onFieldBlur: () => {
+                    field.onBlur();
+                } })) }));
+    }
+    return _jsx(SgInputOTPBase, { ...rest, ref: ref, name: name });
+});

package/dist/inputs/SgToggleSwitch.d.ts

@@ -0,0 +1,36 @@
+import React from "react";
+import type { FieldValues, RegisterOptions, UseFormRegister } from "react-hook-form";
+import type { RhfFieldProps } from "../rhf";
+export type SgToggleSwitchProps = {
+    id: string;
+    label?: string;
+    description?: string;
+    error?: string;
+    className?: string;
+    labelClassName?: string;
+    switchClassName?: string;
+    trackClassName?: string;
+    thumbClassName?: string;
+    onIcon?: React.ReactNode;
+    offIcon?: React.ReactNode;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    width?: number | string;
+    enabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    requiredMessage?: string;
+    validateOnBlur?: boolean;
+    validation?: (checked: boolean) => string | null;
+    onValidation?: (message: string | null) => void;
+    onChange?: (checked: boolean) => void;
+    inputProps?: React.InputHTMLAttributes<HTMLInputElement> & {
+        ref?: React.Ref<HTMLInputElement>;
+    };
+    register?: UseFormRegister<FieldValues>;
+    rules?: RegisterOptions<FieldValues>;
+} & RhfFieldProps;
+export declare function SgToggleSwitch(props: Readonly<SgToggleSwitchProps>): import("react/jsx-runtime").JSX.Element;
+export declare const SgSwitch: typeof SgToggleSwitch;
+export type SgSwitchProps = SgToggleSwitchProps;
+//# sourceMappingURL=SgToggleSwitch.d.ts.map

package/dist/inputs/SgToggleSwitch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SgToggleSwitch.d.ts","sourceRoot":"","sources":["../../src/inputs/SgToggleSwitch.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAGV,WAAW,EACX,eAAe,EACf,eAAe,EAChB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAuC5C,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACzB,OAAO,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,GAAG,IAAI,CAAC;IACjD,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IAChD,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACtC,UAAU,CAAC,EAAE,KAAK,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,GAAG;QACzD,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;KACnC,CAAC;IACF,QAAQ,CAAC,EAAE,eAAe,CAAC,WAAW,CAAC,CAAC;IACxC,KAAK,CAAC,EAAE,eAAe,CAAC,WAAW,CAAC,CAAC;CACtC,GAAG,aAAa,CAAC;AAsNlB,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,CAAC,mBAAmB,CAAC,2CAmDlE;AAED,eAAO,MAAM,QAAQ,uBAAiB,CAAC;AACvC,MAAM,MAAM,aAAa,GAAG,mBAAmB,CAAC"}